activerecord_where_assoc 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ef06d95cd1fa0b3de7d06e745fc1a527bdc86415adb2e6b36b86b1f1477e804
-  data.tar.gz: 36a723c284fbb1e0b44ea9af5368995d504a53026817f545a14235212d4ae7bf
+  metadata.gz: c25ebdab306cdfa08879b9237211c464b023ab1445e2607ae18855b8546730bf
+  data.tar.gz: 76d893474ad646ab75258ab6856050193cd7bd17ccacef8a28fc7dc9e7c2de04
 SHA512:
-  metadata.gz: 8a26660a18b817b6a5cd106e71413e064f899e6fb9c73e9f502a14fc5aeb2896412368bc932028300611c94adac234ebbff85d0e2fd3ed8b900c01fa6c5e2670
-  data.tar.gz: febe936611a53bc9f2f75aeb639fe8d8b905304b9b910e71f5cc9020ab1c0fae6803cd303f0cd7b830e29aa092778df21ce0303150f876930a02be2ed831821e
+  metadata.gz: 110b91b46d60a9dbe82d31784e743e5f4d3cd4d67e3389593c97cd7461d17977e5ba941b265a7d30e04a8455d8c090f86c4ed54be87282d114ac6fa6fe712934
+  data.tar.gz: 14b76e774b2731063a10eaeb4654497c53521d44935172858697e7e9337e9e2032ba742c81e41bb48f925c305c53fd414d5e30817740766570ef60ee9a4853f0

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Unreleased
 
+# 1.3.0 - 2025-03-04
+
+* The arguments of `#where_assoc_count` can now be swapped when comparing to a number or a range. <br>
+  So `where_assoc_count(:posts, :>, 5)` is now valid for having more than 5 posts.
+
+# 1.2.1 - 2024-12-05
+
+* Optimize `has_one` handling for `#where_assoc_exists` with a `has_one` as last association + without any conditions or offset.
+* Optimize `has_one` handling when the foreign_key has a unique index and there is no offset
+
 # 1.2.0 - 2024-08-31
 
 * Add support for composite primary keys in Rails 7.2

data/README.md

@@ -13,7 +13,7 @@ my_post.comments.where_assoc_not_exists(:author, is_admin: true).where(...)
 Post.where_assoc_exists([:comments, :author], &:admins).where(...)
 
 # Find my_user's posts that have at least 5 non-spam comments (not_spam is a scope on comments)
-my_user.posts.where_assoc_count(5, :>=, :comments) { |comments| comments.not_spam }.where(...)
+my_user.posts.where_assoc_count(:comments, :>=, 5) { |comments| comments.not_spam }.where(...)
 ```
 
 These allow for powerful, chainable, clear and easy to reuse queries. (Great for scopes)
@@ -56,7 +56,7 @@ Or install it yourself with:
 
 ## Development state
 
-This gem is feature complete and production ready.  
+This gem is feature complete and production ready.<br>
 Other than rare tweaks as new versions of Rails and Ruby are released, there shouldn't be much activity on this repository.
 
 ## Documentation
@@ -77,45 +77,36 @@ Otherwise, here is a short explanation of the main methods provided by this gem:
 ```ruby
 where_assoc_exists(association_name, conditions, options, &block)
 where_assoc_not_exists(association_name, conditions, options, &block)
-where_assoc_count(left_operand, operator, association_name, conditions, options, &block)
+where_assoc_count(left_assoc_or_value, operator, right_assoc_or_value, conditions, options, &block)
 ```
 
-* These methods add a condition (a `#where`) that checks if the association exists (or not)  
-* You can specify condition on the association, so you could check only for comments that are made by an admin.  
-* Each method returns a new relation, meaning you can chain `#where`, `#order`, `limit`, etc.  
+* These methods add a condition (a `#where`) that checks if the association exists (or not)
+* You can specify condition on the association, so you could check only for comments that are made by an admin.
+* Each method returns a new relation, meaning you can chain `#where`, `#order`, `limit`, etc.
 * common arguments:
   * association_name: the association we are doing the condition on.
   * conditions: (optional) the condition to apply on the association. It can be anything that `#where` can receive, so: Hash, String and Array (string with binds).
   * options: [available options](https://maxlap.github.io/activerecord_where_assoc/ActiveRecordWhereAssoc/RelationReturningMethods#module-ActiveRecordWhereAssoc::RelationReturningMethods-label-Options) to alter some behaviors. (rarely necessary)
-  * block: adds more complex conditions by receiving a relation on the association. Can use `#where`, `#where_assoc_*`, scopes, and other scoping methods.  
-    Must return a relation.
+  * block: adds more complex conditions by receiving a relation on the association. Can use `#where`, `#where_assoc_*`, scopes, and other scoping methods.<br>
+    Must return a relation.<br>
     The block either:
     * receives no argument, in which case `self` is set to the relation, so you can do `{ where(id: 123) }`
     * receives arguments, in which case the block is called with the relation as first parameter.
 
-    The block should return the new relation to use or `nil` to do as if there were no blocks.  
+    The block should return the new relation to use or `nil` to do as if there were no blocks.<br>
     It's common to use `where_assoc_*(..., &:scope_name)` to use a single scope.
 * `#where_assoc_count` is a generalization of `#where_assoc_exists` and `#where_assoc_not_exists`. It behaves the same way, but is more powerful, as it allows you to specify how many matches there should be.
     ```ruby
     # These are equivalent:
     Post.where_assoc_exists(:comments, is_spam: true)
-    Post.where_assoc_count(1, :<=, :comments, is_spam: true)
+    Post.where_assoc_count(:comments, :>=, 1, is_spam: true)
 
     Post.where_assoc_not_exists(:comments, is_spam: true)
-    Post.where_assoc_count(0, :==, :comments, is_spam: true)
+    Post.where_assoc_count(:comments, :==, 0, is_spam: true)
 
     # This has no equivalent (Posts with at least 5 spam comments)
-    Post.where_assoc_count(5, :<=, :comments, is_spam: true)
+    Post.where_assoc_count(:comments, :>=, 5, is_spam: true)
     ```
-* `where_assoc_count`'s additional arguments  
-  The order of the parameters of `#where_assoc_count` may seem confusing, but you will get used to it. It helps to remember: the goal is to do: `5 < (SELECT COUNT(*) FROM ...)`, the number is first, then operator, then the association and its conditions.
-  * left_operand:  
-      * a number  
-      * a string of SQL to embed in the query  
-      * a range (operator must be `:==` or `:!=`)  
-        will use SQL's `BETWEEN` or `NOT BETWEEN`  
-        supports infinite ranges and exclusive end
-  * operator: one of `:<`, `:<=`, `:==`, `:!=`, `:>=`, `:>`
 
 ## Intuition
 
@@ -127,8 +118,8 @@ Here is the basic intuition for the methods:
 
 `#where_assoc_count` the more specific version of `#where_assoc_exists`. Filters the models, returning those *where* a record for the *association* matching a condition (by default any record in the association) do *not exists*
 
-The condition that you may need on the record can be quite complicated. For this reason, you can pass a block to these methods.  
-The block will receive a relation on records of the association. Your job is then to call `where` and scopes to specify what you want to exist (or to not exist if using `#where_assoc_not_exists`). 
+The condition that you may need on the record can be quite complicated. For this reason, you can pass a block to these methods.
+The block will receive a relation on records of the association. Your job is then to call `where` and scopes to specify what you want to exist (or to not exist if using `#where_assoc_not_exists`).
 
 So if you have `User.where_assoc_exists(:comments) {|rel| rel.where("content ilike '%github.com%'") }`, `rel` is a relation is on `Comment`, and you are specifying what you want to exist. So now we are looking for users that made a comment containing 'github.com'.
 
@@ -142,7 +133,7 @@ Sometimes, there isn't a single association that goes deep enough. In that situa
 # Find users that have a post that has a comment that was made by an admin.
 # Using &:admins to use the admins scope (or any other class method of comments)
 User.where_assoc_exists(:posts) { |posts|
-    posts.where_assoc_exists(:comments) { |comments| 
+    posts.where_assoc_exists(:comments) { |comments|
         comments.where_assoc_exists(:author, &:admins)
     }
 }
@@ -223,7 +214,7 @@ On MySQL databases, it is not possible to use `has_one` associations and associa
 
 I do not know of a way to do a SQL query that can deal with all the specifics of `has_one` for MySQL. If you have one, then please suggest it in an issue/pull request.
 
-In order to work around this, you must use the [ignore_limit](https://maxlap.github.io/activerecord_where_assoc/ActiveRecordWhereAssoc/RelationReturningMethods.html#module-ActiveRecordWhereAssoc::RelationReturningMethods-label-3Aignore_limit+option) option. The behavior is less correct, but better than being unable to use the gem. 
+In order to work around this, you must use the [ignore_limit](https://maxlap.github.io/activerecord_where_assoc/ActiveRecordWhereAssoc/RelationReturningMethods.html#module-ActiveRecordWhereAssoc::RelationReturningMethods-label-3Aignore_limit+option) option. The behavior is less correct, but better than being unable to use the gem.
 
 ### has_* :through vs limit/offset
 For `has_many` and `has_one` with the `:through` option, `#limit` and `#offset` are ignored. Note that `#limit` and `#offset` of the `:source` and of the `:through` side are applied correctly.

data/lib/active_record_where_assoc/active_record_compat.rb

@@ -101,5 +101,28 @@ module ActiveRecordWhereAssoc
         reflection.is_a?(ActiveRecord::NullRelation)
       end
     end
+
+    if ActiveRecord.gem_version >= Gem::Version.new("6.0")
+      def self.indexes(model)
+        model.connection.schema_cache.indexes(model.table_name)
+      end
+    else
+      def self.indexes(model)
+        model.connection.indexes(model.table_name)
+      end
+    end
+
+    @unique_indexes_cache = {}
+    def self.has_unique_index?(model, column_names)
+      column_names = Array(column_names).map(&:to_s)
+      @unique_indexes_cache.fetch([model, column_names]) do |k|
+        unique_indexes = indexes(model).select(&:unique)
+        columns_names_set = Set.new(column_names)
+
+        # We check for an index whose columns are a subset of the columns we specify
+        # This way, a composite column_names will find uniqueness if just a single of the column is unique
+        @unique_indexes_cache[k] = unique_indexes.any? { |ui| Set.new(ui.columns) <= columns_names_set }
+      end
+    end
   end
 end

data/lib/active_record_where_assoc/core_logic.rb

@@ -7,6 +7,17 @@ module ActiveRecordWhereAssoc
   module CoreLogic
     # Arel table used for aliasing when handling recursive associations (such as parent/children)
     ALIAS_TABLE = Arel::Table.new("_ar_where_assoc_alias_")
+    OPERATOR_SWAP_OPERANDS = {
+      "<" => ">",
+      "<=" => ">=",
+      ">" => "<",
+      ">=" => "<=",
+      # Below stays the same
+      "=" => "=",
+      "==" => "==",
+      "!=" => "!=",
+      "<>" => "<>",
+    }
 
     # Returns the SQL for checking if any of the received relation exists.
     # Uses a OR if there are multiple relations.
@@ -92,7 +103,28 @@ module ActiveRecordWhereAssoc
     # Returns the SQL condition to check if the specified association of the record_class has the desired number of records.
     #
     # See RelationReturningMethods#where_assoc_count or SqlReturningMethods#compare_assoc_count_sql for usage details.
-    def self.compare_assoc_count_sql(record_class, left_operand, operator, association_names, given_conditions, options, &block)
+    #
+    # The codebase originally only allowed where_assoc_count(5, :<, :comments).
+    # This has since been considered confusing and error prone, with `where_assoc_count(:comments, :>, 5)` being preferable.
+    # So we want to allow the better way to work.
+    # However:
+    # * We originally already allowed any valid SQL to be given as left valid (even a symbol that names a column).
+    # * We don't want this to be a breaking change
+    #
+    # Because of this, it is not simple to correctly auto-detect which situation we are in.
+    # So only the simple and most common case of using a number or a range on the right side (3rd argument) is supported.
+    #
+    # And due to this history, the generated SQL will still have the counting SQL on the right side.
+    def self.compare_assoc_count_sql(record_class, left_assoc_or_value, operator, right_assoc_or_value, given_conditions, options, &block)
+      if right_assoc_or_value.is_a?(Numeric) || right_assoc_or_value.is_a?(Range)
+        association_names = left_assoc_or_value
+        left_operand = right_assoc_or_value
+        operator = OPERATOR_SWAP_OPERANDS.fetch(operator.to_s)
+      else
+        association_names = right_assoc_or_value
+        left_operand = left_assoc_or_value
+      end
+
       right_sql = only_assoc_count_sql(record_class, association_names, given_conditions, options, &block)
 
       sql_for_count_operator(left_operand, operator, right_sql)
@@ -155,9 +187,17 @@ module ActiveRecordWhereAssoc
 
         init_scopes = initial_scopes_from_reflection(record_class, reflection_chain[i..-1], constraints_chain[i], options)
         current_scopes = init_scopes.map do |alias_scope, current_scope, klass_scope|
-          current_scope = process_association_step_limits(current_scope, reflection, record_class, options)
-
           if i.zero?
+            if given_conditions || klass_scope || last_assoc_block || current_scope.offset_value || nest_assocs_block == NestWithSumBlock
+              # In the deepest layer, the limit & offset complexities only matter when:
+              # * There is a condition to apply
+              # * There is an offset (which is a form of filtering)
+              # * We are counting the total matches
+              # Since last_assoc_block is always set except for the deepest association, and is only unset for the deepest layer if
+              # there is no condition given, using it as part of the condition does a lot of work here.
+              current_scope = process_association_step_limits(current_scope, reflection, record_class, options)
+            end
+
             current_scope = current_scope.where(given_conditions) if given_conditions
             if klass_scope
               if klass_scope.respond_to?(:call)
@@ -167,6 +207,8 @@ module ActiveRecordWhereAssoc
               end
             end
             current_scope = apply_proc_scope(current_scope, last_assoc_block) if last_assoc_block
+          else
+            current_scope = process_association_step_limits(current_scope, reflection, record_class, options)
           end
 
           # Those make no sense since at this point, we are only limiting the value that would match using conditions
@@ -338,10 +380,18 @@ module ActiveRecordWhereAssoc
 
       current_scope = current_scope.limit(1) if reflection.macro == :has_one
 
-      # Order is useless without either limit or offset
-      current_scope = current_scope.unscope(:order) if !current_scope.limit_value && !current_scope.offset_value
+      if !current_scope.offset_value
+        if current_scope.limit_value
+          join_keys = ActiveRecordCompat.join_keys(reflection, nil)
+          # #join_keys is inverted... the foreign key is on the "source" table, and the key is on the "target" table...
+          # Everything is so complicated in ActiveRecord.
+          current_scope = current_scope.unscope(:limit) if ActiveRecordCompat.has_unique_index?(current_scope.model, join_keys.key)
+        end
+
+        # Order is useless without either limit or offset
+        return current_scope.unscope(:order) if !current_scope.limit_value
+      end
 
-      return current_scope unless current_scope.limit_value || current_scope.offset_value
       if %w(mysql mysql2).include?(relation_klass.connection.adapter_name.downcase)
         msg = String.new
         msg << "Associations and default_scopes with a limit or offset are not supported for MySQL (this includes has_many). "

data/lib/active_record_where_assoc/relation_returning_methods.rb

@@ -313,18 +313,18 @@ module ActiveRecordWhereAssoc
     # To clarify, here are equivalent examples:
     #
     #   Post.where_assoc_exists(:comments)
-    #   Post.where_assoc_count(1, :<=, :comments)
+    #   Post.where_assoc_count(:comments, :>=, 1)
     #
     #   Post.where_assoc_not_exists(:comments)
-    #   Post.where_assoc_count(0, :==, :comments)
+    #   Post.where_assoc_count(:comments, :==, 0)
     #
-    # But these have no equivalent:
+    # But these have no equivalent with the *_exists methods:
     #
     #   # Posts with at least 5 comments
-    #   Post.where_assoc_count(5, :<=, :comments)
+    #   Post.where_assoc_count(:comments, :>=, 5)
     #
     #   # Posts with less than 5 comments
-    #   Post.where_assoc_count(5, :>, :comments)
+    #   Post.where_assoc_count(:comments, :<, 5)
     #
     # You could say this is a way of doing a +#select+ that +#count+ the associations of your model
     # on the SQL side, but faster and more concise.
@@ -332,20 +332,30 @@ module ActiveRecordWhereAssoc
     # Examples (with an equivalent ruby +#select+ and +#count+)
     #
     #   # Posts with at least 5 comments
-    #   Post.where_assoc_count(5, :<=, :comments)
+    #   Post.where_assoc_count(:comments, :>=, 5)
     #   Post.all.select { |post| post.comments.count >= 5 }
     #
     #   # Posts that have at least 5 comments marked as spam
-    #   Post.where_assoc_count(5, :<=, :comments, is_spam: true)
+    #   Post.where_assoc_count(:comments, :>=, 5, is_spam: true)
     #   Post.all.select { |post| post.comments.where(is_spam: true).count >= 5 }
     #
     #   # Posts that have at least 10 replies spread over their comments
-    #   Post.where_assoc_count(10, :<=, [:comments, :replies])
-    #   Post.select { |post| post.comments.sum { |comment| comment.replies.count } >= 5 }
+    #   Post.where_assoc_count([:comments, :replies], :>=, 10)
+    #   Post.select { |post| post.comments.sum { |comment| comment.replies.count } >= 10 }
     #
-    # [left_operand]
+    # Note: Originally, the order of the arguments used to have to be: `where_assoc_count(5, :<, :comments)`.
+    # This was confusing and error prone, with `where_assoc_count(:comments, :>, 5)` appearing preferable.
+    # However, due to the flexibility of what could already be received as first argument, it was not
+    # simple to detect all cases of the arguments being swapped. We didn't want this to be a breaking change.
+    #
+    # So a special case was made for the main case of using a number or a range. This means the only time where
+    # the association_name(s) can be the first argument is when using a number.<br>
+    # Otherwise, the association_names must be the third arguments, such as: where_assoc_count("Some SQL", :<, :comments)
+    #
+    # [left_assoc_or_value]
     #   1st argument, the left side of the comparison. <br>
     #   One of:
+    #   * If using a number or a range as third argument, this can be the association_name(s). (See third parameter)
     #   * a number
     #   * a string of SQL to embed in the query
     #   * a range (operator must be :== or :!=), will use BETWEEN or NOT BETWEEN<br>
@@ -353,20 +363,27 @@ module ActiveRecordWhereAssoc
     #
     #     # Posts with 5 to 10 comments
     #     Post.where_assoc_count(5..10, :==, :comments)
+    #     Post.where_assoc_count(:comments, :==, 5..10) # Equivalent
     #
     #     # Posts with less than 5 or more than 10 comments
     #     Post.where_assoc_count(5..10, :!=, :comments)
+    #     Post.where_assoc_count(:comments, :!=, 5..10) # Equivalent
     #
     # [operator]
     #   The operator to use, one of these symbols: <code>  :<  :<=  :==  :!=  :>=  :>  </code>
     #
-    # [association_name]
+    # [right_assoc_or_value]
+    #   If the first argument was the association_name(s), then this must be a number or a range.
+    #
+    #   Otherwise, this must be the association_names(s).
+    #
     #   The association that must have a certain number of occurrences <br>
-    #   Note that if you use an array of association names, the number of the last association
+    #   Note that if you use an array of association names, the total number of the last association
     #   is what is counted.
     #
     #     # Users which have received at least 5 comments total (can be spread on all of their posts)
     #     User.where_assoc_count(5, :<=, [:posts, :comments])
+    #     User.where_assoc_count([:posts, :comments], :>=, 5)
     #
     #   See RelationReturningMethods@Association
     #
@@ -382,26 +399,28 @@ module ActiveRecordWhereAssoc
     #   More complex conditions the associated record must match (can also use scopes of the association's model) <br>
     #   See RelationReturningMethods@Block
     #
-    # The order of the parameters may seem confusing. But you will get used to it. It helps
-    # to remember that the goal is to do:
+    # The order of the parameters may seem confusing. That's an mistake that cannot be fixed without a breaking change.
+    # That's why there is now a special case for using a number or range as third argument. Note that the generated SQL will always
+    # place the counting SQL on the right side. (Reversing the operator when needed), like so:
     #    5 < (SELECT COUNT(*) FROM ...)
-    # So the parameters are in the same order as in that query: number, operator, association.
     #
     # To be clear, when you use multiple associations in an array, the count you will be
     # comparing against is the total number of records of that last association.
     #
     #   # The users that have received at least 5 comments total on all of their posts
     #   # So this can be from one post that has 5 comments of from 5 posts with 1 comments
+    #   User.where_assoc_count([:posts, :comments], :>=, 5)
     #   User.where_assoc_count(5, :<=, [:posts, :comments])
     #
     #   # The users that have at least 5 posts with at least one comments
     #   User.where_assoc_count(5, :<=, :posts) { where_assoc_exists(:comments) }
+    #   User.where_assoc_count(:posts, :>=, 5) { where_assoc_exists(:comments) }
     #
     # You can get the SQL string of the condition using SqlReturningMethods#compare_assoc_count_sql.
     # You can get the SQL string for only the counting using SqlReturningMethods#only_assoc_count_sql.
-    def where_assoc_count(left_operand, operator, association_name, conditions = nil, options = {}, &block)
-      sql = ActiveRecordWhereAssoc::CoreLogic.compare_assoc_count_sql(self.klass, left_operand, operator,
-                                                                      association_name, conditions, options, &block)
+    def where_assoc_count(left_assoc_or_value, operator, right_assoc_or_value, conditions = nil, options = {}, &block)
+      sql = ActiveRecordWhereAssoc::CoreLogic.compare_assoc_count_sql(self.klass, left_assoc_or_value, operator,
+                                                                      right_assoc_or_value, conditions, options, &block)
       where(sql)
     end
   end

data/lib/active_record_where_assoc/sql_returning_methods.rb

@@ -45,13 +45,18 @@ module ActiveRecordWhereAssoc
     #
     # For example:
     #   # Users with at least 10 posts or at least 10 comment
+    #   User.where("#{User.compare_assoc_count_sql(:posts, :>=, 10)} OR #{User.compare_assoc_count_sql(:comments, :>=, 10)}")
+    #   my_users.where("#{User.compare_assoc_count_sql(:posts, :>=, 10)} OR #{User.compare_assoc_count_sql(:comments, :>=, 10)}")
+    #
+    #   # The older way of doing the same thing (the order of parameter used to be reversed,
+    #   # both order work when using a number or a range as one of the operand)
     #   User.where("#{User.compare_assoc_count_sql(10, :<=, :posts)} OR #{User.compare_assoc_count_sql(10, :<=, :comments)}")
     #   my_users.where("#{User.compare_assoc_count_sql(10, :<=, :posts)} OR #{User.compare_assoc_count_sql(10, :<=, :comments)}")
     #
     # The parameters are the same as RelationReturningMethods#where_assoc_count, including the
     # possibility of specifying a list of association_name.
-    def compare_assoc_count_sql(left_operand, operator, association_name, conditions = nil, options = {}, &block)
-      ActiveRecordWhereAssoc::CoreLogic.compare_assoc_count_sql(self, left_operand, operator, association_name, conditions, options, &block)
+    def compare_assoc_count_sql(left_assoc_or_value, operator, right_assoc_or_value, conditions = nil, options = {}, &block)
+      ActiveRecordWhereAssoc::CoreLogic.compare_assoc_count_sql(self, left_assoc_or_value, operator, right_assoc_or_value, conditions, options, &block)
     end
 
     # This method returns a string containing the SQL to count an association used by RelationReturningMethods#where_assoc_count.

data/lib/active_record_where_assoc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveRecordWhereAssoc
-  VERSION = "1.2.0".freeze
+  VERSION = "1.3.0".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord_where_assoc
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Maxime Handfield Lapointe
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-08-31 00:00:00.000000000 Z
+date: 2025-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -31,9 +31,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.15'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '2.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -41,9 +38,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.15'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '2.6'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement