active_record-where_exists 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fdd433c489a4724c42ae1b7937377978134063af8215d12a4c0209685b3b163f
+  data.tar.gz: f60d150867ca8bb71cf4b52fbce58b542eb1c2e2c9bf756f557655deacf3973c
+SHA512:
+  metadata.gz: eab9ab3196e655f9b16e96dfc904c78bea0f62328757d31ca89ec17014ba06be043a19e9a80da04eec1cd5fad8631592965b92d663b208144b84b16dee04d702
+  data.tar.gz: 9f524b218a58afe7f25771a551299d7ece04f604c8a9877feb6ef43d4106e9a8149fb093eeefe02893b141a6e0b95c55a52702db031062b3617f4be374e08d2f

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2026 Minty Fresh
+
+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,161 @@
+# ActiveRecord::WhereExists
+
+Filters ActiveRecord records by the existence of associated records, using correlated `EXISTS` subqueries.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'active_record-where_exists', github: 'mintyfresh/active_record-where_exists'
+```
+
+And then execute:
+
+```bash
+$ bundle
+```
+
+Then extend your models with `ActiveRecord::WhereExists` (typically in `ApplicationRecord`, so all models get it):
+
+```ruby
+class ApplicationRecord < ActiveRecord::Base
+  primary_abstract_class
+
+  extend ActiveRecord::WhereExists
+end
+```
+
+## Usage
+
+Given:
+
+```ruby
+class User < ApplicationRecord
+  has_many :orders
+  has_many :completed_orders, -> { completed }, class_name: 'Order'
+end
+```
+
+`where.exists` filters records to those with associated records matching a relation:
+
+```ruby
+User.where.exists(orders: Order.completed)
+# SELECT "users".* FROM "users" WHERE EXISTS (
+#   SELECT 1 FROM "orders" WHERE "orders"."status" = 'completed' AND "orders"."user_id" = "users"."id"
+# )
+```
+
+And `where.not_exists` filters records to those without them:
+
+```ruby
+User.where.not_exists(orders: Order.completed)
+```
+
+Associations given by name match any associated record (ie. `exists(:orders)` is the same as `exists(orders: Order.all)`):
+
+```ruby
+User.where.exists(:orders)
+User.where.not_exists(:orders)
+```
+
+Several associations can be given at once. Records must match all of them with `exists`, and none of them with `not_exists`:
+
+```ruby
+User.where.exists(:addresses, orders: Order.completed)
+```
+
+### Association scopes
+
+The subquery is constrained in the same way as joining the association (ie. `joins(:association)`).
+So it applies the scope of the association, as well as the default scope of the associated model:
+
+```ruby
+User.where.exists(completed_orders: Order.where(total: 100..))
+# SELECT "users".* FROM "users" WHERE EXISTS (
+#   SELECT 1 FROM "orders"
+#   WHERE "orders"."total" >= 100.0 AND "orders"."status" = 'completed' AND "orders"."user_id" = "users"."id"
+# )
+```
+
+It also respects extensions to how associations are joined, such as the filtering of soft-deleted records by
+[SoftDeletable](https://github.com/mintyfresh/soft_deletable).
+
+Note that, as with joins, ordering in the scope of a `has_one` association is ignored.
+So `exists(latest_order: Order.completed)` matches records with any completed order.
+
+### Procs
+
+Associated records can also be filtered by a proc, which is given a relation of the associated records:
+
+```ruby
+User.where.exists(orders: -> (orders) { orders.completed })
+```
+
+A proc is needed for self-referential associations (or any association to the table of the records being filtered),
+where the associated records are referred to by an alias, so that their conditions apply to the alias:
+
+```ruby
+class User < ApplicationRecord
+  has_many :friendships
+  has_many :friends, through: :friendships
+end
+
+User.where.exists(friends: -> (friends) { friends.where(name: 'Alice') })
+# SELECT "users".* FROM "users" WHERE EXISTS (
+#   SELECT 1 FROM "users" AS "friends_users"
+#   INNER JOIN "friendships" ON "friends_users"."id" = "friendships"."friend_id"
+#   WHERE "friends_users"."name" = 'Alice' AND "friendships"."user_id" = "users"."id"
+# )
+```
+
+Relations that refer to the table of the records being filtered (eg. `User.where.exists(friends: User.all)`,
+or `User.where.exists(orders: Order.joins(:user))`) raise an `ArgumentError`, since their conditions would be
+ambiguous between the associated records and the records being filtered.
+
+### Supported associations
+
+All kinds of associations are supported, including `has_many :through`, `has_and_belongs_to_many`,
+and self-referential associations.
+
+Polymorphic `belongs_to` associations need a relation (or model), which specifies the type of the associated record:
+
+```ruby
+class Comment < ApplicationRecord
+  belongs_to :commentable, polymorphic: true
+end
+
+Comment.where.exists(commentable: Post.published)
+Comment.where.exists(commentable: Post)
+```
+
+### Projections
+
+The subquery selects `1` (so the database doesn't need to read the rows of the associated table),
+unless the relation has its own projection, which is kept:
+
+```ruby
+User.where.exists(orders: Order.select(:user_id).group(:user_id).having('SUM(total) > 100'))
+```
+
+### Sorbet
+
+A Tapioca DSL compiler is included, which adds the `exists` and `not_exists` methods
+to the where-chains generated for models extended by `ActiveRecord::WhereExists`.
+It's loaded automatically by `bin/tapioca dsl`.
+
+## Development
+
+The specs run against a dummy Rails application in `spec/dummy`, using SQLite by default:
+
+```bash
+$ bin/rspec
+$ bin/rubocop
+```
+
+PostgreSQL and MySQL are selected with the `DATABASE_ADAPTER` and `DATABASE_URL` environment variables
+(see `.github/workflows/ci.yml`).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/active_record/where_exists/association_subquery.rb

@@ -0,0 +1,236 @@
+# typed: true
+# frozen_string_literal: true
+
+module ActiveRecord
+  module WhereExists
+    # Builds the subquery selecting the associated records of each row of an outer relation.
+    #
+    # The subquery is constrained as if joining the association (ie. `joins(:association)`), so it respects the scope
+    # of the association, the default scope of the associated model, and any extensions to how associations are joined.
+    #
+    #   User.where.exists(orders: Order.completed)
+    #   # SELECT "users".* FROM "users" WHERE EXISTS (
+    #   #   SELECT 1 FROM "orders" WHERE "orders"."status" = 'completed' AND "orders"."user_id" = "users"."id"
+    #   # )
+    class AssociationSubquery
+      # The relation that the subquery selects from, the table it refers to the associated records by,
+      # and the tables already in use by the subquery.
+      Target = Data.define(:relation, :table, :alias_tracker)
+
+      #: ActiveRecord::Reflection::AbstractReflection
+      attr_reader :reflection
+
+      # The associated records can be filtered by a relation (or model), or by a proc which is given a relation of the
+      # associated records (on the table they're referred to by, eg. an alias in self-referential associations).
+      # Associations given by name match any associated record (ie. `exists(:orders)` is `exists(orders: Order.all)`,
+      # or `exists(friends: -> (friends) { friends })` when the associated records are aliased).
+      #
+      #: (
+      #|   ActiveRecord::Relation scope,
+      #|   ActiveRecord::Reflection::AbstractReflection reflection,
+      #|   (
+      #|     ActiveRecord::Relation | singleton(ActiveRecord::Base) | ^(ActiveRecord::Relation) -> ActiveRecord::Relation
+      #|   )? condition
+      #| ) -> void
+      def initialize(scope, reflection, condition)
+        @scope = scope
+        @reflection = reflection
+        @condition = condition
+
+        reflection.check_validity!
+        validate_polymorphic! if reflection.polymorphic?
+      end
+
+      # Selects a constant unless the relation has its own projection (eg. for a GROUP BY),
+      # so that the database needn't read the rows of the subquery (eg. when an index covers its conditions).
+      #
+      #: -> Arel::Nodes::Exists
+      def exists
+        subquery = relation
+        subquery = subquery.select(Arel.sql('1')) if subquery.select_values.empty?
+        subquery.arel.exists
+      end
+
+      # The associated records of each row of the outer relation, as a relation correlated to its table.
+      #
+      #: -> ActiveRecord::Relation
+      def relation
+        @relation ||= reflection.polymorphic? ? build_polymorphic : build
+      end
+
+    private
+
+      #: -> Arel::Table
+      def outer_table
+        @scope.table
+      end
+
+      # Polymorphic associations are resolved by the model of the relation.
+      #
+      #: -> singleton(ActiveRecord::Base)
+      def klass
+        reflection.polymorphic? ? @condition.all.klass : reflection.klass
+      end
+
+      #: -> void
+      def validate_polymorphic!
+        return if @condition.is_a?(ActiveRecord::Relation)
+        return if @condition.is_a?(Class) && @condition < ActiveRecord::Base
+
+        raise ArgumentError, "A relation or model must be given for the polymorphic association `:#{reflection.name}`."
+      end
+
+      #: (untyped relation) -> void
+      def validate_relation!(relation)
+        unless relation.is_a?(ActiveRecord::Relation) && relation.klass.base_class == klass.base_class
+          raise ArgumentError, "Expected a relation of `#{klass.name}` for the association `:#{reflection.name}`, " \
+                               "got #{relation.inspect}."
+        end
+
+        validate_outer_table_unshadowed!(relation)
+      end
+
+      # The subquery refers to the outer table by name, so none of the relation's tables may share its name.
+      #
+      #: (ActiveRecord::Relation relation) -> void
+      def validate_outer_table_unshadowed!(relation)
+        return if target_alias_tracker(relation).aliases[outer_table.name].zero?
+
+        name = reflection.name
+        raise ArgumentError, "The relation for the association `:#{name}` refers to the outer table " \
+                             "`#{outer_table.name}`. Pass a proc to filter the associated records by their own " \
+                             "table, e.g. `#{name}: -> (#{name}) { #{name}.where(...) }`."
+      end
+
+      # Tracks the tables of the relation, so that the tables joined by the association are aliased apart from them.
+      #
+      #: (ActiveRecord::Relation relation) -> ActiveRecord::Associations::AliasTracker
+      def target_alias_tracker(relation)
+        ActiveRecord::Associations::AliasTracker.create(
+          klass.connection_pool, relation.table.name, relation.arel.join_sources
+        )
+      end
+
+      # Builds the subquery from the joins of the association, which start from the outer table:
+      #
+      #   FROM outer INNER JOIN t1 ON c1 INNER JOIN t2 ON c2 ... INNER JOIN target ON cN
+      #
+      # and are rearranged to start from the target table (where the relation's conditions apply),
+      # moving the condition on the outer table into the subquery's WHERE clause:
+      #
+      #   FROM target INNER JOIN tN-1 ON cN ... INNER JOIN t1 ON c2 WHERE c1
+      #
+      #: -> ActiveRecord::Relation
+      def build
+        tables, joins = association_joins
+
+        # the chain of tables starts at the target, and its conditions each join a table to the next one
+        conditions = tables.map { |table| joins.find { |join| join.left.equal?(table) }.right.expr }
+        chain_joins = tables.drop(1).zip(conditions).map do |table, condition|
+          Arel::Nodes::InnerJoin.new(table, Arel::Nodes::On.new(condition))
+        end
+
+        join_all(target.relation, chain_joins + scope_joins(tables, joins)).where(conditions.last)
+      end
+
+      # Joins from the scopes of the association, which aren't part of the chain.
+      #
+      #: (Array[Arel::Table | Arel::Nodes::TableAlias] tables, Array[Arel::Nodes::Join] joins) -> Array[Arel::Nodes::Join]
+      def scope_joins(tables, joins)
+        joins.reject { |join| tables.any? { |table| join.left.equal?(table) } }
+      end
+
+      # Joins the association from the outer table, as `joins(:association)` would.
+      #
+      #: -> [Array[Arel::Table | Arel::Nodes::TableAlias], Array[Arel::Nodes::Join]]
+      def association_joins
+        tables = [] #: Array[Arel::Table | Arel::Nodes::TableAlias]
+        join_association = ActiveRecord::Associations::JoinDependency::JoinAssociation.new(reflection, [])
+
+        joins = join_association.join_constraints(
+          outer_table, @scope.model, Arel::Nodes::InnerJoin, target.alias_tracker
+        ) do |step|
+          tables << (tables.empty? ? target.table : intermediate_table(step))
+          tables.last
+        end
+
+        [tables, joins]
+      end
+
+      #: (ActiveRecord::Relation relation, Array[Arel::Nodes::Join] joins) -> ActiveRecord::Relation
+      def join_all(relation, joins)
+        joins.empty? ? relation : relation.joins(*joins)
+      end
+
+      #: (ActiveRecord::Reflection::AbstractReflection step) -> (Arel::Table | Arel::Nodes::TableAlias)
+      def intermediate_table(step)
+        target.alias_tracker.aliased_table_for(step.klass.arel_table) do
+          "#{step.alias_candidate(outer_table.name)}_join"
+        end
+      end
+
+      # Polymorphic associations can't be joined, so the target is given by the relation.
+      #
+      #: -> ActiveRecord::Relation
+      def build_polymorphic
+        predicate_builder = klass.predicate_builder.with(ActiveRecord::TableMetadata.new(klass, target.table))
+        association_scopes = reflection.join_scopes(target.table, predicate_builder, klass)
+
+        association_scopes.inject(target.relation, &:merge).where(Arel::Nodes::And.new(polymorphic_conditions))
+      end
+
+      #: -> Array[Arel::Nodes::Node]
+      def polymorphic_conditions
+        keys = Array(reflection.join_primary_key(klass)).zip(Array(reflection.join_foreign_key))
+
+        conditions = keys.map { |primary_key, foreign_key| target.table[primary_key].eq(outer_table[foreign_key]) }
+        conditions << outer_table[reflection.foreign_type].eq(klass.polymorphic_name)
+      end
+
+      #: -> Target
+      def target
+        @target ||= begin
+          relation = resolve_condition
+          validate_relation!(relation)
+
+          alias_tracker = target_alias_tracker(relation)
+          alias_tracker.aliased_table_for(outer_table)
+
+          Target.new(relation, relation.table, alias_tracker)
+        end
+      end
+
+      # Procs may return anything, so the result is validated by `validate_relation!`.
+      #
+      #: -> untyped
+      def resolve_condition
+        case @condition
+        when nil then associated_records
+        when Proc then @condition.call(associated_records)
+        else @condition.all
+        end
+      end
+
+      # A relation of every associated record, on the table they're referred to by.
+      # They're aliased when their table is the outer table (eg. in self-referential associations).
+      # (The default scope of the model is applied by the association's join constraints.)
+      #
+      #: -> ActiveRecord::Relation
+      def associated_records
+        return klass.all if klass.table_name != outer_table.name
+
+        table = klass.arel_table.alias(associated_records_alias)
+        predicate_builder = klass.predicate_builder.with(ActiveRecord::TableMetadata.new(klass, table))
+
+        ActiveRecord::Relation.create(klass, table:, predicate_builder:)
+      end
+
+      #: -> String
+      def associated_records_alias
+        klass.connection_pool.with_connection do |connection|
+          connection.table_alias_for(reflection.alias_candidate(outer_table.name))
+        end
+      end
+    end
+  end
+end

data/lib/active_record/where_exists/relation_extension.rb

@@ -0,0 +1,17 @@
+# typed: true
+# frozen_string_literal: true
+
+module ActiveRecord
+  module WhereExists
+    module RelationExtension
+      # Returns a where-chain supporting `exists` and `not_exists` when called without arguments.
+      #
+      #: (*untyped args) -> untyped
+      def where(*args)
+        return super unless args.empty?
+
+        WhereChain.new(spawn)
+      end
+    end
+  end
+end

data/lib/active_record/where_exists/version.rb

@@ -0,0 +1,8 @@
+# typed: true
+# frozen_string_literal: true
+
+module ActiveRecord
+  module WhereExists
+    VERSION = '0.1.0'
+  end
+end

data/lib/active_record/where_exists/where_chain.rb

@@ -0,0 +1,67 @@
+# typed: true
+# frozen_string_literal: true
+
+module ActiveRecord
+  module WhereExists
+    class WhereChain < ActiveRecord::QueryMethods::WhereChain
+      # Filters records to those with associated records.
+      # Associations can be given by name, or mapped to a relation (or model) that associated records must match,
+      # or to a proc which filters a relation of the associated records:
+      #
+      #   User.where.exists(:orders)
+      #   User.where.exists(orders: Order.completed)
+      #   User.where.exists(friends: -> (friends) { friends.where(name: 'Alice') })
+      #
+      # A proc is needed when the associated records are in the same table as the records being filtered
+      # (eg. in self-referential associations), since the associated records are then referred to by an alias.
+      #
+      # Records must match every condition given.
+      #
+      #: (
+      #|   *Symbol | String associations,
+      #|   **(
+      #|     ActiveRecord::Relation | singleton(ActiveRecord::Base) | ^(ActiveRecord::Relation) -> ActiveRecord::Relation
+      #|   ) scoped_associations
+      #| ) -> ActiveRecord::Relation
+      def exists(*associations, **scoped_associations)
+        each_subquery(associations, scoped_associations) { |subquery| @scope.where!(subquery.exists) }
+        @scope
+      end
+
+      # Filters records to those without associated records (see `exists`).
+      #
+      #   User.where.not_exists(:orders)
+      #   User.where.not_exists(orders: Order.completed)
+      #   User.where.not_exists(friends: -> (friends) { friends.where(name: 'Alice') })
+      #
+      # Records must match none of the conditions given.
+      #
+      #: (
+      #|   *Symbol | String associations,
+      #|   **(
+      #|     ActiveRecord::Relation | singleton(ActiveRecord::Base) | ^(ActiveRecord::Relation) -> ActiveRecord::Relation
+      #|   ) scoped_associations
+      #| ) -> ActiveRecord::Relation
+      def not_exists(*associations, **scoped_associations)
+        each_subquery(associations, scoped_associations) { |subquery| @scope.where!(subquery.exists.not) }
+        @scope
+      end
+
+    private
+
+      #: (
+      #|   Array[Symbol | String] associations,
+      #|   Hash[Symbol | String, untyped] scoped_associations
+      #| ) { (AssociationSubquery) -> void } -> void
+      def each_subquery(associations, scoped_associations)
+        if associations.empty? && scoped_associations.empty?
+          raise ArgumentError, 'At least one association must be given.'
+        end
+
+        associations.map { |name| [name, nil] }.concat(scoped_associations.to_a).each do |name, relation|
+          yield AssociationSubquery.new(@scope, scope_association_reflection(name), relation)
+        end
+      end
+    end
+  end
+end

data/lib/active_record/where_exists.rb

@@ -0,0 +1,48 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'active_record'
+require 'active_record/where_exists/version'
+
+module ActiveRecord
+  # Adds `where.exists` and `where.not_exists` to the relations of a model and its subclasses,
+  # which filter records by the existence of associated records, using correlated `EXISTS` subqueries:
+  #
+  #   class ApplicationRecord < ActiveRecord::Base
+  #     extend ActiveRecord::WhereExists
+  #   end
+  #
+  #   User.where.exists(orders: Order.completed)
+  #   User.where.not_exists(:orders)
+  module WhereExists
+    autoload :AssociationSubquery, 'active_record/where_exists/association_subquery'
+    autoload :RelationExtension, 'active_record/where_exists/relation_extension'
+    autoload :WhereChain, 'active_record/where_exists/where_chain'
+
+    class << self
+      # Extends the relations of a model, and of any of its subclasses that were already defined.
+      #
+      #: (singleton(ActiveRecord::Base) base) -> void
+      def extended(base)
+        super
+        [base, *base.descendants].each(&:install_where_exists)
+      end
+    end
+
+    # Rails builds the relation classes of each model as it's defined (see `ActiveRecord::Delegation::DelegateCache`),
+    # so subclasses defined after the model was extended are installed here.
+    #
+    #: -> void
+    def initialize_relation_delegate_cache
+      super
+      install_where_exists
+    end
+
+    #: -> void
+    def install_where_exists
+      ActiveRecord::Delegation.delegated_classes.each do |relation_class|
+        relation_delegate_class(relation_class).include(RelationExtension)
+      end
+    end
+  end
+end

data/lib/tapioca/dsl/compilers/active_record_where_exists.rb

@@ -0,0 +1,70 @@
+# typed: strict
+# frozen_string_literal: true
+
+return unless defined?(ActiveRecord::Base)
+
+require 'tapioca/dsl/compilers/active_record_relations'
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # Adds `exists` and `not_exists` to the where-chains generated by the ActiveRecordRelations compiler,
+      # for models extended by ActiveRecord::WhereExists.
+      # Compilers decorate a constant in order of their names, so this runs after ActiveRecordRelations.
+      #
+      #: [ConstantType = singleton(::ActiveRecord::Base)]
+      class ActiveRecordWhereExists < Compiler
+        include Helpers::ActiveRecordConstantsHelper
+
+        WHERE_CHAIN_METHODS = %w[exists not_exists].freeze #: Array[String]
+
+        # Procs are given a relation of the associated model, which depends on the association, so it's untyped.
+        SCOPED_ASSOCIATION_TYPE = 'T.any(' \
+                                  '::ActiveRecord::Relation, ' \
+                                  'T.class_of(::ActiveRecord::Base), ' \
+                                  'T.proc.params(relation: T.untyped).returns(::ActiveRecord::Relation)' \
+                                  ')' #: String
+
+        # @override
+        #: -> void
+        def decorate
+          return unless compiler_enabled?('ActiveRecordRelations')
+
+          root.create_path(constant) do |model|
+            model.create_class(RelationWhereChainClassName) do |klass|
+              create_where_chain_methods(klass, RelationClassName)
+            end
+
+            model.create_class(AssociationRelationWhereChainClassName) do |klass|
+              create_where_chain_methods(klass, AssociationRelationClassName)
+            end
+          end
+        end
+
+        class << self
+          # @override
+          #: -> Enumerable[Module[top]]
+          def gather_constants
+            ActiveRecordRelations.gather_constants.grep(::ActiveRecord::WhereExists)
+          end
+        end
+
+      private
+
+        #: (RBI::Scope scope, String return_type) -> void
+        def create_where_chain_methods(scope, return_type)
+          WHERE_CHAIN_METHODS.each do |name|
+            scope.create_method(
+              name,
+              parameters: [
+                create_rest_param('associations', type: 'T.any(Symbol, String)'),
+                create_kw_rest_param('scoped_associations', type: SCOPED_ASSOCIATION_TYPE),
+              ],
+              return_type:
+            )
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: active_record-where_exists
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Minty Fresh
+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: '8.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.1'
+description: Adds where.exists and where.not_exists to ActiveRecord relations, filtering
+  records by the existence of associated records.
+email:
+- 7896757+mintyfresh@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/active_record/where_exists.rb
+- lib/active_record/where_exists/association_subquery.rb
+- lib/active_record/where_exists/relation_extension.rb
+- lib/active_record/where_exists/version.rb
+- lib/active_record/where_exists/where_chain.rb
+- lib/tapioca/dsl/compilers/active_record_where_exists.rb
+homepage: https://github.com/mintyfresh/active_record-where_exists
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/mintyfresh/active_record-where_exists
+  source_code_uri: https://github.com/mintyfresh/active_record-where_exists
+  rubygems_mfa_required: 'true'
+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: 4.0.20
+specification_version: 4
+summary: EXISTS subqueries for ActiveRecord associations
+test_files: []