active-query 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc0875fc4b5ba6101ea1b0198145966d5dde1b46a366e4ec007938add33977fa
-  data.tar.gz: 2dfd5ebdf7a88d312f3485fd5a8e0c464763f52d7d41c61624c3e5293fcc0228
+  metadata.gz: 426f4c764e93fcdacda7b354b9f4597ced451648ac4a0e56052f9cfc239f6d3f
+  data.tar.gz: b8e7db1ca8f99f4851a469feb412539c93a41e66f2d9d676ff619197dacf53a9
 SHA512:
-  metadata.gz: cb35c0ba08e4ebf370796648920edcd6aeadfc14f50aa3ea4c9d8ec605f53085a09bea9913eedc7bf59f2de057d9e97a50aed5ff4e61cdfca87e96b76de07eec
-  data.tar.gz: 287d91f5c9291112ba6bf9aa99aabc4f32466ed76995da6a092492250228693ba1b535cd5d7147c601a67fd6e69c5fb24bb9cc415ee3d5b232392e9e7d8d0a8b
+  metadata.gz: 5437dc8c0c0e0ca61883a52799bc927c5bc710d708192be2fb1bd661c2f638e188d842be6098f3692d9fbd515a5659cdf881d684d49425ec9212e8d0b0d119b6
+  data.tar.gz: 7352b91b01bfa4fe0e96a9d6ad026f6a8ad6e1182d372e879c4eb0fdf453f2f410cd3f0016426b4a22ff9e42dd1f5cd6a45d21269340d20d89c87173142889f7

data/Appraisals

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+appraise 'rails-7.0' do
+  gem 'activerecord', '~> 7.0.0'
+  gem 'activesupport', '~> 7.0.0'
+  gem 'sqlite3', '~> 1.4'
+end
+
+appraise 'rails-7.1' do
+  gem 'activerecord', '~> 7.1.0'
+  gem 'activesupport', '~> 7.1.0'
+  gem 'sqlite3', '~> 1.4'
+end
+
+appraise 'rails-8.0' do
+  gem 'activerecord', '~> 8.0.0'
+  gem 'activesupport', '~> 8.0.0'
+  gem 'sqlite3', '~> 2.1'
+end

data/CHANGELOG.md

@@ -7,6 +7,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.3] - 2024-12-19
+
+### Added
+- Support for Rails 8.0
+- Compatibility with SQLite3 version 2.1+ required by Rails 8
+- Updated CI matrix to test against Rails 8.0
+
 ## [0.0.1] - 2024-12-19
 
 ### Added
@@ -31,5 +38,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Resolvers**: Support complex query logic with resolver classes
 - **Conditional Logic**: Apply scopes conditionally with `if`/`unless`
 
-[Unreleased]: https://github.com/matiasasis/active-query/compare/v0.0.1...HEAD
+[Unreleased]: https://github.com/matiasasis/active-query/compare/v0.1.3...HEAD
+[0.1.3]: https://github.com/matiasasis/active-query/compare/v0.0.1...v0.1.3
 [0.0.1]: https://github.com/matiasasis/active-query/releases/tag/v0.0.1

data/README.md

@@ -1,14 +1,16 @@
 # ActiveQuery
 
-ActiveQuery is a gem that helps you create query objects in a simple way. It provides a DSL to define queries and scopes for your query object, making it easier to organize and reuse complex database queries.
+ActiveQuery is a Ruby gem that helps you create clean, reusable query objects with a simple DSL. It provides type validation, conditional logic, and seamless ActiveRecord integration.
 
 ## Features
 
-- **Query Objects**: Create reusable query objects with a clean DSL
-- **Type Validation**: Built-in argument type validation
-- **Scopes**: Define custom scopes for your queries
-- **Operations**: Additional query operations like `gt`, `lt`, `like`, etc.
-- **Resolvers**: Support for resolver pattern for complex queries
+- **Clean Query DSL**: Define queries with clear syntax and descriptions
+- **Type Safety**: Built-in argument type validation (String, Integer, Float, Boolean)
+- **Optional & Default Arguments**: Flexible argument handling
+- **Custom Operations**: Extended query operations like `gt`, `lt`, `like`, etc.
+- **Conditional Logic**: Apply scopes conditionally with `if` and `unless`
+- **Resolver Pattern**: Support for complex query logic in separate classes
+- **Custom Scopes**: Define reusable scopes within query objects
 - **ActiveRecord Integration**: Works seamlessly with ActiveRecord models
 
 ## Installation
@@ -25,175 +27,365 @@ And then execute:
 bundle install
 ```
 
-Or install it yourself as:
-
-```bash
-gem install active-query
-```
-
 ## Usage
 
 ### Basic Query Object
 
-Create a query object by including `ActiveQuery::Base`:
+Create a query object by including `ActiveQuery::Base` and defining queries with the `query` method:
 
 ```ruby
 class UserQuery
   include ActiveQuery::Base
-  
+
   # The model is automatically inferred from the class name (User)
-  # Or you can explicitly set it:
-  # model_name 'User'
-  
-  query :by_email, 'Find users by email', { email: { type: String } } do |email:|
-    scope.where(email: email)
-  end
-  
-  query :active, 'Find active users' do
-    scope.where(active: true)
-  end
+  # Or explicitly set it:
+  model_name 'User'
+
+  # Simple query without arguments
+  query :active, 'Returns all active users', -> { scope.where(active: true) }
+
+  # Query with arguments and type validation
+  query :by_email, 'Find users by email address',
+    { email: { type: String } },
+    -> (email:) { scope.where(email: email) }
 end
 ```
 
 ### Using Query Objects
 
 ```ruby
-# Find users by email
-users = UserQuery.by_email(email: 'john@example.com')
-
-# Find active users
+# Execute queries
 active_users = UserQuery.active
+user = UserQuery.by_email(email: 'john@example.com')
 
-# Chain queries
-active_users_with_email = UserQuery.active.by_email(email: 'john@example.com')
+# Chain with ActiveRecord methods
+recent_active_users = UserQuery.active.where('created_at > ?', 1.week.ago)
 ```
 
-### Query Arguments with Types
+### Argument Types and Validation
+
+ActiveQuery supports several argument types with automatic validation:
 
 ```ruby
 class ProductQuery
   include ActiveQuery::Base
-  
-  query :by_price_range, 'Find products within price range', {
-    min_price: { type: Float },
-    max_price: { type: Float, optional: true },
-    include_tax: { type: ActiveQuery::Base::Boolean, default: false }
-  } do |min_price:, max_price:, include_tax:|
-    scope.where('price >= ?', min_price)
-         .then { |s| max_price ? s.where('price <= ?', max_price) : s }
-         .then { |s| include_tax ? s.where(tax_included: true) : s }
-  end
+
+  query :filter_products, 'Filter products by various criteria',
+    {
+      name: { type: String },
+      price: { type: Float },
+      quantity: { type: Integer },
+      available: { type: Boolean }
+    },
+    -> (name:, price:, quantity:, available:) {
+      scope.where(name: name)
+           .where(price: price)
+           .where(quantity: quantity)
+           .where(available: available)
+    }
 end
 
-# Usage
-products = ProductQuery.by_price_range(min_price: 10.0, max_price: 100.0, include_tax: true)
-```
+# Usage with type validation
+ProductQuery.filter_products(
+  name: 'Widget',
+  price: 19.99,
+  quantity: 10,
+  available: true
+)
 
-### Custom Scopes
+# This will raise ArgumentError due to type mismatch
+ProductQuery.filter_products(name: 123, price: 'invalid', quantity: true, available: 'yes')
+```
 
-Define reusable scopes within your query object:
+### Optional Arguments and Defaults
 
 ```ruby
 class OrderQuery
   include ActiveQuery::Base
-  include ActiveQuery::Scopes
-  
-  scope :recent, -> { where('created_at > ?', 1.week.ago) }
-  scope :completed, -> { where(status: 'completed') }
-  
-  query :recent_completed, 'Find recent completed orders' do
-    scope.recent.completed
-  end
+
+  query :search_orders, 'Search orders with optional filters',
+    {
+      status: { type: String },
+      paid: { type: Boolean, default: true },
+      customer_name: { type: String, optional: true }
+    },
+    -> (status:, paid:, customer_name:) {
+      scope.where(status: status)
+           .where(paid: paid)
+           .if(customer_name, -> { where('customer_name LIKE ?', "%#{customer_name}%") })
+    }
 end
+
+# Usage - customer_name is optional, paid defaults to true
+OrderQuery.search_orders(status: 'pending')
+OrderQuery.search_orders(status: 'completed', customer_name: 'John')
+OrderQuery.search_orders(status: 'pending', paid: false, customer_name: 'Jane')
 ```
 
-### Operations
+### Conditional Query Logic
 
-ActiveQuery provides additional query operations:
+Use `if` and `unless` methods for conditional query building:
 
 ```ruby
 class UserQuery
   include ActiveQuery::Base
-  
-  query :by_age_range, 'Find users by age range', {
-    min_age: { type: Integer, optional: true },
-    max_age: { type: Integer, optional: true }
-  } do |min_age:, max_age:|
-    scope.then { |s| min_age ? s.gteq(:age, min_age) : s }
-         .then { |s| max_age ? s.lteq(:age, max_age) : s }
-  end
-  
-  query :by_name, 'Find users by name pattern', { name: { type: String } } do |name:|
-    scope.like(:name, name)
-  end
+
+  query :search_users, 'Search users with conditional filters',
+    {
+      name: { type: String, optional: true },
+      active: { type: Boolean, optional: true }
+    },
+    -> (name:, active:) {
+      scope.if(name.present?, -> { where('name LIKE ?', "%#{name}%") })
+           .if(active == true, -> { where(active: true) })
+    }
+
+  query :filter_unless_admin, 'Filter users unless they are admin',
+    {
+      role: { type: String, optional: true }
+    },
+    -> (role:) {
+      scope.unless(role == 'admin', -> { where.not(role: 'admin') })
+    }
+end
+```
+
+### Extended Query Operations
+
+ActiveQuery provides additional query operations beyond standard ActiveRecord:
+
+```ruby
+class ProductQuery
+  include ActiveQuery::Base
+
+  # Comparison operations
+  query :expensive_products, 'Products above price threshold', -> { scope.gt(:price, 100) }
+  query :affordable_products, 'Products within budget', -> { scope.lteq(:price, 50) }
+
+  # Text search operations
+  query :search_by_name, 'Search products by name pattern', -> { scope.like(:name, 'Phone') }
+  query :products_starting_with, 'Products starting with prefix', -> { scope.start_like(:name, 'iPhone') }
+  query :products_ending_with, 'Products ending with suffix', -> { scope.end_like(:name, 'Pro') }
+
+  # Dynamic filtering
+  query :by_price_range, 'Filter by price range',
+    { min_price: { type: Float }, max_price: { type: Float } },
+    -> (min_price:, max_price:) {
+      scope.gteq(:price, min_price)
+           .lteq(:price, max_price)
+    }
 end
 ```
 
-Available operations:
+**Available operations:**
 - `gt(column, value)` - greater than
 - `gteq(column, value)` - greater than or equal
-- `lt(column, value)` - less than  
+- `lt(column, value)` - less than
 - `lteq(column, value)` - less than or equal
-- `like(column, value)` - contains pattern
+- `like(column, value)` - contains pattern (wraps with %)
 - `start_like(column, value)` - starts with pattern
 - `end_like(column, value)` - ends with pattern
 
-### Resolvers
+### Custom Scopes
 
-For complex queries, you can use the resolver pattern:
+Define reusable scopes within your query objects:
 
 ```ruby
+class UserQuery
+  include ActiveQuery::Base
+  include ActiveQuery::Scopes
+
+  # Define custom scopes
+  module Scopes
+    include ActiveQuery::Scopes
+
+    scope :recent, -> { where('created_at > ?', 1.month.ago) }
+    scope :by_role, -> (role:) { where(role: role) }
+  end
+
+  # Use scopes in queries
+  query :recent_admins, 'Find recent admin users', -> { scope.recent.by_role(role: 'admin') }
+
+  query :count_recent, 'Count recent users', -> { scope.recent.count }
+end
+```
+
+### Resolver Pattern
+
+For complex query logic, use the resolver pattern to keep your query objects clean:
+
+```ruby
+# Define a resolver
 class UserStatsResolver < ActiveQuery::Resolver
-  def resolve(status: nil)
-    query = scope.joins(:orders)
-    query = query.where(status: status) if status
-    query.group(:id).having('COUNT(orders.id) > 5')
+  def resolve(min_orders: 5)
+    scope.joins(:orders)
+         .group('users.id')
+         .having('COUNT(orders.id) >= ?', min_orders)
+         .select('users.*, COUNT(orders.id) as order_count')
   end
 end
 
+# Use resolver in query object
 class UserQuery
   include ActiveQuery::Base
-  
-  query :with_many_orders, 'Users with many orders', {
-    status: { type: String, optional: true }
-  }, resolver: UserStatsResolver
+
+  # Resolver without arguments
+  query :high_value_users, 'Users with many orders',
+    resolver: UserStatsResolver
+
+  # Resolver with arguments
+  query :users_with_orders, 'Users with minimum order count',
+    { min_orders: { type: Integer } },
+    resolver: UserStatsResolver
 end
 
 # Usage
-users = UserQuery.with_many_orders(status: 'active')
+UserQuery.high_value_users
+UserQuery.users_with_orders(min_orders: 10)
 ```
 
-### Conditional Queries
+### Query Introspection
 
-Use `if` and `unless` for conditional query building:
+Query objects provide metadata about available queries:
 
 ```ruby
-class ProductQuery
+class UserQuery
   include ActiveQuery::Base
-  
-  query :search, 'Search products', {
-    name: { type: String, optional: true },
-    category: { type: String, optional: true },
-    on_sale: { type: ActiveQuery::Base::Boolean, optional: true }
-  } do |name:, category:, on_sale:|
-    scope.if(name.present?, -> { where('name ILIKE ?', "%#{name}%") })
-         .if(category.present?, -> { where(category: category) })
-         .if(on_sale == true, -> { where('sale_price IS NOT NULL') })
+
+  query :active, 'Find active users', -> { scope.where(active: true) }
+  query :by_name, 'Find by name', { name: { type: String } }, -> (name:) { scope.where(name: name) }
+end
+
+# Get all available queries
+UserQuery.queries
+# => [
+#   { name: :active, description: "Find active users", args_def: {} },
+#   { name: :by_name, description: "Find by name", args_def: { name: { type: String } } }
+# ]
+```
+
+### Error Handling
+
+ActiveQuery provides clear error messages for common mistakes:
+
+```ruby
+# Missing required arguments
+UserQuery.by_email
+# => ArgumentError: Params missing: [:email]
+
+# Wrong argument type
+UserQuery.by_email(email: 123)
+# => ArgumentError: :email must be of type String
+
+# Unknown arguments
+UserQuery.by_email(email: 'test@example.com', invalid_param: 'value')
+# => ArgumentError: Unknown params: [:invalid_param]
+
+# Optional and default together (validation error)
+query :invalid_query, 'This will fail',
+  { param: { type: String, optional: true, default: 'value' } },
+  -> (param:) { scope }
+# => ArgumentError: Optional and Default params can't be present together: [:param]
+```
+
+### Integration with Rails
+
+ActiveQuery works seamlessly with Rails applications:
+
+```ruby
+# app/queries/user_query.rb
+class UserQuery
+  include ActiveQuery::Base
+
+  query :active, 'Active users', -> { scope.where(active: true) }
+  query :by_role, 'Users by role', { role: { type: String } }, -> (role:) { scope.where(role: role) }
+end
+
+# In controllers
+class UsersController < ApplicationController
+  def index
+    @users = UserQuery.active
+  end
+
+  def admins
+    @admins = UserQuery.by_role(role: 'admin')
   end
 end
+
+# In views or anywhere else
+<%= UserQuery.active.count %> active users
 ```
 
 ## Requirements
 
-- Ruby >= 2.6.0
-- ActiveRecord >= 6.1
-- ActiveSupport >= 6.1
+- Ruby >= 3.2.0
+- ActiveRecord >= 6.1, < 9.0
+- ActiveSupport >= 6.1, < 9.0
+
+### Rails 8 Support
+
+ActiveQuery fully supports Rails 8.0! Note that Rails 8 requires SQLite3 version 2.1 or higher:
+
+```ruby
+# For Rails 8 applications
+gem 'sqlite3', '~> 2.1'
+
+# For Rails 7 and below
+gem 'sqlite3', '~> 1.4'
+```
+
+See [RAILS_8_MIGRATION.md](RAILS_8_MIGRATION.md) for detailed migration instructions.
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`.
+
+### Testing Against Multiple Rails Versions
+
+This gem is tested against Rails 7.0, 7.1, and 8.0 to ensure compatibility across versions.
+
+#### Running Tests Locally
+
+To test against all supported Rails versions locally:
+
+```bash
+# Test against all Rails versions
+./bin/test_all_rails
+
+# Test against a specific Rails version
+BUNDLE_GEMFILE=gemfiles/rails_7_0.gemfile bundle exec rake spec
+BUNDLE_GEMFILE=gemfiles/rails_7_1.gemfile bundle exec rake spec
+BUNDLE_GEMFILE=gemfiles/rails_8_0.gemfile bundle exec rake spec
+```
+
+#### Using Appraisal (Alternative Method)
+
+If you prefer using the `appraisal` gem:
+
+```bash
+# Install appraisal gemfiles
+bundle exec appraisal install
+
+# Run tests against all Rails versions
+bundle exec appraisal rake spec
+
+# Run tests against specific Rails version
+bundle exec appraisal rails-7-0 rake spec
+bundle exec appraisal rails-7-1 rake spec
+bundle exec appraisal rails-8-0 rake spec
+```
+
+#### Continuous Integration
+
+The gem uses GitHub Actions to automatically test against multiple Ruby and Rails versions in a matrix configuration. Each push and pull request triggers tests across:
+
+- Ruby versions: 3.2, 3.3
+- Rails versions: 7.0, 7.1, 8.0
+- Appropriate SQLite3 versions for each Rails version (1.4 for Rails 7.x, 2.1+ for Rails 8.0)
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+See `.github/workflows/main.yml` for the complete CI configuration.
 
 ## Contributing
 
@@ -205,4 +397,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the ActiveQuery project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/matiasasis/active-query/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in the ActiveQuery project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/matiasasis/active-query/blob/master/CODE_OF_CONDUCT.md).

data/active-query.gemspec

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "lib/active_query/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "active-query"
+  spec.version = ActiveQuery::VERSION
+  spec.authors = ["Matias Asis"]
+  spec.email = ["matiasis.90@gmail.com"]
+
+  spec.summary = "ActiveQuery is a gem that helps you to create query objects in a simple way."
+  spec.description = "ActiveQuery is a gem that helps you to create query objects in a simple way. It provides a DSL to define queries and scopes for your query object."
+  spec.homepage = "https://github.com/matiasasis/active-query"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.2.0"
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/matiasasis/active-query"
+  spec.metadata["bug_tracker_uri"] = "https://github.com/matiasasis/active-query/issues"
+  spec.metadata["changelog_uri"] = "https://github.com/matiasasis/active-query/blob/master/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  spec.metadata['rubygems_mfa_required'] = 'true'
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .github appveyor Gemfile]) ||
+        f.match?(/\.gem\z/)
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  # Dependencies
+  spec.add_dependency 'activerecord', '>= 6.1', '< 9.0'
+  spec.add_dependency 'activesupport', '>= 6.1', '< 9.0'
+
+  # Dev dependencies
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rspec', '~> 3.9.0'
+  spec.add_development_dependency 'simplecov', '~> 0.17.1'
+  spec.add_development_dependency 'sqlite3', '>= 1.5.1', '< 3.0'
+  spec.add_development_dependency 'database_cleaner-active_record', '~> 2.2.0'
+  spec.add_development_dependency 'byebug', '~> 11.0'
+  spec.add_development_dependency 'appraisal', '~> 2.4'
+end

data/gemfiles/rails_7_0.gemfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec path: ".."
+
+gem "activerecord", "~> 7.0.0"
+gem "activesupport", "~> 7.0.0"
+gem "sqlite3", "~> 1.4"

data/gemfiles/rails_7_1.gemfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec path: ".."
+
+gem "activerecord", "~> 7.1.0"
+gem "activesupport", "~> 7.1.0"
+gem "sqlite3", "~> 1.4"

data/gemfiles/rails_8_0.gemfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec path: ".."
+
+gem "activerecord", "~> 8.0.0"
+gem "activesupport", "~> 8.0.0"
+gem "sqlite3", "~> 2.1"

data/lib/active-query.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'active_query'

data/lib/active_query/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveQuery
-  VERSION = '0.1.1'
+  VERSION = '0.1.3'
 end

data/lib/active_query.rb

@@ -84,7 +84,7 @@ module ActiveQuery
       def query_with_arguments(name, description, args_def, lambda)
         register_query(name, description, args_def)
 
-        define_singleton_method(name) do |given_args|
+        define_singleton_method(name) do |given_args = {}|
           given_args = validate_args(name, given_args, args_def)
           lambda.call(**given_args)
         end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: active-query
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Matias Asis
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-08-06 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -19,7 +18,7 @@ dependencies:
         version: '6.1'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '8.0'
+        version: '9.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,7 +28,7 @@ dependencies:
         version: '6.1'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '8.0'
+        version: '9.0'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -39,7 +38,7 @@ dependencies:
         version: '6.1'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '8.0'
+        version: '9.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -49,7 +48,7 @@ dependencies:
         version: '6.1'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '8.0'
+        version: '9.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -96,16 +95,22 @@ dependencies:
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.5.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.5.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: database_cleaner-active_record
   requirement: !ruby/object:Gem::Requirement
@@ -134,6 +139,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '11.0'
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
 description: ActiveQuery is a gem that helps you to create query objects in a simple
   way. It provides a DSL to define queries and scopes for your query object.
 email:
@@ -145,12 +164,18 @@ extra_rdoc_files: []
 files:
 - ".byebug_history"
 - ".rspec"
+- Appraisals
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - LICENSE.txt
 - README.md
 - Rakefile
+- active-query.gemspec
 - exe/active-query
+- gemfiles/rails_7_0.gemfile
+- gemfiles/rails_7_1.gemfile
+- gemfiles/rails_8_0.gemfile
+- lib/active-query.rb
 - lib/active_query.rb
 - lib/active_query/resolver.rb
 - lib/active_query/version.rb
@@ -164,7 +189,6 @@ metadata:
   bug_tracker_uri: https://github.com/matiasasis/active-query/issues
   changelog_uri: https://github.com/matiasasis/active-query/blob/master/CHANGELOG.md
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -172,15 +196,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.15
-signing_key:
+rubygems_version: 4.0.2
 specification_version: 4
 summary: ActiveQuery is a gem that helps you to create query objects in a simple way.
 test_files: []