active_record_extended 1.3.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c136dceff4eb13a4c368aef03c70ae74bf3c856d3dadaa38e468e3f3369455d
-  data.tar.gz: 1d7f194a4760a812e2a6aa22f20e1a62914e68d1fcb52cb223d724104597cc31
+  metadata.gz: 7f3f7041cc4869183bc20b38f8387bd8f3f216225990a62ec0c4e0fba5f847dd
+  data.tar.gz: c61e5ad1c2fae32a5dbfe8660bb888d85f255f285a2df8b1f02206f51cbd71b7
 SHA512:
-  metadata.gz: a0d6e454d6c2dc91d28472cc1911043bc62a94e554d85bc77b0cdbbdedcc4158f7f6f43164a7cd5b27d8609ececf4b532f9a4ebe26c725267c77de4b1c201d38
-  data.tar.gz: 28980520ea5779c79a9fd131157a5b2cdecba1d1fa8464dbba34ef299501094e97db64db303c5d0ad51cf3cb2a52b130562a71d64f866e67f6446ce79082de74
+  metadata.gz: c27cf6541f3e11a3beb00263be7c1478e8f4ddb64b0121ed141347ca995252453864bd3cf0992038b7ea2aa1c409f50792800fdf909d8e544edd470af35231fa
+  data.tar.gz: d0426b00cca79e3d0d145fb87fdd05c25611ff5bfde95c8c1845a281786bd4c7e6bfbd866df46cb8ce1ccd45ab5b4bd91aa83e6c21db879721436574f90087cf

data/README.md

@@ -52,11 +52,12 @@ Active Record Extended is essentially providing users with the other half of Pos
 ## Compatibility
 
 This package is designed align and work with any officially supported Ruby and Rails versions.
- - Minimum Ruby Version: 2.3.x **(EOL warning!)**
- - Minimum Rails Version: 5.0.x **(EOL warning!)**
- - Latest Ruby supported: 2.6.x
- - Latest Rails supported: 6.0.x
- - Postgres: 9.6-current(11) (probably works with most older versions to a certain point)
+ - Minimum Ruby Version: 2.4.x **(EOL warning!)**
+ - Minimum Rails Version: 5.1.x **(EOL warning!)**
+ - Minimum Postgres Version: 9.6.x **(EOL warning!)**
+ - Latest Ruby supported: 3.0.x
+ - Latest Rails supported: 7.0.x
+ - Postgres: 9.6-current(13) (probably works with most older versions to a certain point)
 
 ## Installation
 
@@ -430,7 +431,7 @@ While quite the mouthful of an explanation. The implementation of combining unre
     product_query  = 
     Product.select(:id)
             .joins(:items)
-            .select_row_to_json(item_query, key: :outer_items, as: :items, cast_as_array: true) do |item_scope|
+            .select_row_to_json(item_query, key: :outer_items, as: :items, cast_with: :array) do |item_scope|
               item_scope.where("outer_items.product_id = products.id")
                 # Results to: 
                 #  SELECT ..., ARRAY(SELECT ROW_TO_JSON("outer_items")   
@@ -440,7 +441,7 @@ While quite the mouthful of an explanation. The implementation of combining unre
             end
                    
     # Not defining a key will automatically generate a random key between a-z 
-    category_query = Category.select(:name, :id).select_row_to_json(product_query, as: :products, cast_as_array: true)
+    category_query = Category.select(:name, :id).select_row_to_json(product_query, as: :products, cast_with: :array)
     Category.json_build_object(:physical_category, category_query.where(id: physical_cat.id)).results
     #=> {
     #        "physical_category" => {
@@ -648,12 +649,12 @@ SELECT "people".*
 
 ```ruby
 users               = Person.where(id: 1..5)
-expect_these_users  = Person.where(id: 2..4)
+except_these_users  = Person.where(id: 2..4)
 
-Person.union_except(users, expect_these_users) #=> [#<Person id: 1, ..>, #<Person id: 5,..>]
+Person.union_except(users, except_these_users) #=> [#<Person id: 1, ..>, #<Person id: 5,..>]
 
 # You can also chain union's
-Person.union.except(users, expect_these_users).union(Person.where(id: 20))
+Person.union.except(users, except_these_users).union(Person.where(id: 20))
 ```
 
 Query Output

data/lib/active_record_extended/active_record/relation_patch.rb

@@ -14,7 +14,22 @@ module ActiveRecordExtended
 
     module Merger
       def normal_values
-        super + [:with, :union, :define_window]
+        super + [:union, :define_window]
+      end
+
+      def merge
+        merge_ctes!
+        super
+      end
+
+      def merge_ctes!
+        return unless other.with_values?
+
+        if other.recursive_value? && !relation.recursive_value?
+          relation.with!(:chain).recursive(other.cte)
+        else
+          relation.with!(other.cte)
+        end
       end
     end
 

data/lib/active_record_extended/active_record.rb

@@ -1,10 +1,5 @@
 # frozen_string_literal: true
 
-# TODO: Remove this when ruby 2.3 support is dropped
-unless Hash.instance_methods(false).include?(:compact!)
-  require "active_support/all"
-end
-
 require "active_record"
 require "active_record/relation"
 require "active_record/relation/merger"
@@ -23,12 +18,8 @@ require "active_record_extended/query_methods/inet"
 require "active_record_extended/query_methods/json"
 require "active_record_extended/query_methods/select"
 
-if ActiveRecord::VERSION::MAJOR == 5 && ActiveRecord::VERSION::MINOR <= 1
-  if ActiveRecord::VERSION::MINOR.zero?
-    require "active_record_extended/patch/5_0/regex_match"
-    require "active_record_extended/patch/5_0/predicate_builder_decorator"
-  end
+if Gem::Requirement.new("~> 5.1.0").satisfied_by?(ActiveRecord.gem_version)
   require "active_record_extended/patch/5_1/where_clause"
-elsif ActiveRecord::VERSION::MAJOR >= 5
+else
   require "active_record_extended/patch/5_2/where_clause"
 end

data/lib/active_record_extended/arel/nodes.rb

@@ -5,28 +5,31 @@ require "arel/nodes/function"
 
 module Arel
   module Nodes
-    %w[
-      Overlap
-      Contains
-      ContainsHStore
-      ContainsArray
-      ContainedInArray
+    if Gem::Requirement.new("< 6.1").satisfied_by?(ActiveRecord.gem_version)
+      ["Contains", "Overlaps"].each { |binary_node_name| const_set(binary_node_name, Class.new(::Arel::Nodes::Binary)) }
+    end
+
+    [
+      "ContainsHStore",
+      "ContainsArray",
+      "ContainedInArray"
     ].each { |binary_node_name| const_set(binary_node_name, Class.new(::Arel::Nodes::Binary)) }
 
-    %w[
-      RowToJson
-      JsonBuildObject
-      JsonbBuildObject
-      ToJson
-      ToJsonb
-      Array
-      ArrayAgg
+    [
+      "RowToJson",
+      "JsonBuildObject",
+      "JsonbBuildObject",
+      "ToJson",
+      "ToJsonb",
+      "Array",
+      "ArrayAgg"
     ].each do |function_node_name|
       func_klass = Class.new(::Arel::Nodes::Function) do
         def initialize(*args)
           super
           return if @expressions.is_a?(::Array)
-          @expressions = @expressions.is_a?(::Arel::Node) ? [@expressions] : [::Arel.sql(@expressions)]
+
+          @expressions = @expressions.is_a?(::Arel::Nodes::Node) ? [@expressions] : [::Arel.sql(@expressions)]
         end
       end
 
@@ -34,12 +37,12 @@ module Arel
     end
 
     module Inet
-      %w[
-        Contains
-        ContainsEquals
-        ContainedWithin
-        ContainedWithinEquals
-        ContainsOrContainedWithin
+      [
+        "Contains",
+        "ContainsEquals",
+        "ContainedWithin",
+        "ContainedWithinEquals",
+        "ContainsOrContainedWithin"
       ].each { |binary_node_name| const_set(binary_node_name, Class.new(::Arel::Nodes::Binary)) }
     end
   end

data/lib/active_record_extended/arel/predications.rb

@@ -14,9 +14,10 @@ module Arel
       Arel::Nodes::Equality.new(Nodes.build_quoted(other, self), all_tags_function)
     end
 
-    def overlap(other)
-      Nodes::Overlap.new(self, Nodes.build_quoted(other, self))
+    def overlaps(other)
+      Nodes::Overlaps.new(self, Nodes.build_quoted(other, self))
     end
+    alias overlap overlaps
 
     def contains(other)
       Nodes::Contains.new self, Nodes.build_quoted(other, self)

data/lib/active_record_extended/arel/sql_literal.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "arel/nodes/sql_literal"
+
+# CTE alias fix for Rails 6.1
+module Arel
+  module Nodes
+    module SqlLiteralDecorator
+      def name
+        self
+      end
+    end
+  end
+end
+
+Arel::Nodes::SqlLiteral.prepend(Arel::Nodes::SqlLiteralDecorator)

data/lib/active_record_extended/arel/visitors/postgresql_decorator.rb

@@ -9,7 +9,7 @@ module ActiveRecordExtended
 
       # rubocop:disable Naming/MethodName
 
-      def visit_Arel_Nodes_Overlap(object, collector)
+      def visit_Arel_Nodes_Overlaps(object, collector)
         infix_value object, collector, " && "
       end
 

data/lib/active_record_extended/arel.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_record_extended/arel/nodes"
+require "active_record_extended/arel/sql_literal"
 require "active_record_extended/arel/aggregate_function_name"
 require "active_record_extended/arel/predications"
 require "active_record_extended/arel/visitors/postgresql_decorator"

data/lib/active_record_extended/query_methods/any_of.rb

@@ -61,13 +61,14 @@ module ActiveRecordExtended
       # In Rails 5.2 the arel table maintains attribute binds
       def bind_attributes(query)
         return [] unless query.respond_to?(:bound_attributes)
+
         query.bound_attributes.map(&:value)
       end
 
       # Rails 5.1 fix
       def unprepared_query(query)
-        query.gsub(/((?<!\\)'.*?(?<!\\)'|(?<!\\)".*?(?<!\\)")|(\=\ \$\d+)/) do |match|
-          Regexp.last_match(2)&.gsub(/\=\ \$\d+/, "= ?") || match
+        query.gsub(/((?<!\\)'.*?(?<!\\)'|(?<!\\)".*?(?<!\\)")|(=\ \$\d+)/) do |match|
+          Regexp.last_match(2)&.gsub(/=\ \$\d+/, "= ?") || match
         end
       end
 
@@ -78,9 +79,9 @@ module ActiveRecordExtended
       def generate_where_clause(query)
         case query
         when String, Hash
-          @scope.where(query)
+          @scope.unscoped.where(query)
         when Array
-          @scope.where(*query)
+          @scope.unscoped.where(*query)
         else
           query
         end

data/lib/active_record_extended/query_methods/either.rb

@@ -30,7 +30,7 @@ module ActiveRecordExtended
       end
 
       def sort_order_sql(dir)
-        %w[asc desc].include?(dir.to_s) ? dir.to_s : "asc"
+        ["asc", "desc"].include?(dir.to_s) ? dir.to_s : "asc"
       end
 
       def xor_field_options(options)
@@ -52,6 +52,7 @@ module ActiveRecordExtended
       def xor_field_options_for_associations(associations)
         associations.each_with_object({}) do |association_name, options|
           reflection = reflect_on_association(association_name)
+          reflection = reflection.through_reflection if reflection.through_reflection?
           options[reflection.table_name] = reflection.foreign_key
         end
       end

data/lib/active_record_extended/query_methods/inet.rb

@@ -74,8 +74,12 @@ module ActiveRecordExtended
       #  #=> "SELECT \"users\".* FROM \"users\" WHERE \"users\".\"ip\" && '127.0.0.255/32'"
       #
       def inet_contains_or_is_contained_within(opts, *rest)
-        substitute_comparisons(opts, rest, Arel::Nodes::Inet::ContainsOrContainedWithin,
-                               "inet_contains_or_is_contained_within")
+        substitute_comparisons(
+          opts,
+          rest,
+          Arel::Nodes::Inet::ContainsOrContainedWithin,
+          "inet_contains_or_is_contained_within"
+        )
       end
     end
   end

data/lib/active_record_extended/query_methods/json.rb

@@ -8,7 +8,7 @@ module ActiveRecordExtended
         :json_build_object,
         :jsonb_build_object,
         :json_build_literal,
-        :jsonb_build_literal,
+        :jsonb_build_literal
       ].freeze
 
       class JsonChain
@@ -51,7 +51,7 @@ module ActiveRecordExtended
         private
 
         def build_json_literal(arel_klass, values:, col_alias: DEFAULT_ALIAS)
-          json_values    = flatten_to_sql(values.to_a, &method(:literal_key))
+          json_values    = flatten_to_sql(values.to_a) { |value| literal_key(value) }
           col_alias      = double_quote(col_alias)
           json_build_obj = arel_klass.new(json_values)
           @scope.select(nested_alias_escape(json_build_obj, col_alias))
@@ -77,7 +77,7 @@ module ActiveRecordExtended
           row_to_json = ::Arel::Nodes::ToJsonb.new(row_to_json) if options.dig(:cast_with, :to_jsonb)
 
           dummy_table = from_clause_constructor(from, key).select(row_to_json)
-          dummy_table = dummy_table.instance_eval(&block) if block_given?
+          dummy_table = dummy_table.instance_eval(&block) if block
           return dummy_table if options[:col_alias].blank?
 
           query = wrap_row_to_json(dummy_table, options)
@@ -98,7 +98,6 @@ module ActiveRecordExtended
           end
         end
 
-        # TODO: [V2 release] Drop support for option :cast_as_array in favor of a more versatile :cast_with option
         def json_object_options(args, except: [], only: []) # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity
           options   = {}
           lean_opts = lambda do |key, &block|
@@ -113,12 +112,12 @@ module ActiveRecordExtended
             next if arg.nil?
 
             if arg.is_a?(Hash)
-              lean_opts.call(:key)       { arg.delete(:key) || key_generator }
-              lean_opts.call(:value)     { arg.delete(:value).presence }
-              lean_opts.call(:col_alias) { arg.delete(:as) }
-              lean_opts.call(:order_by)  { order_by_expression(arg.delete(:order_by)) }
-              lean_opts.call(:from)      { arg.delete(:from).tap(&method(:pipe_cte_with!)) }
-              lean_opts.call(:cast_with) { casting_options(arg.delete(:cast_with) || arg.delete(:cast_as_array)) }
+              lean_opts.call(:key)       { arg.fetch(:key, key_generator) }
+              lean_opts.call(:value)     { arg[:value].presence }
+              lean_opts.call(:col_alias) { arg[:as] }
+              lean_opts.call(:order_by)  { order_by_expression(arg[:order_by]) }
+              lean_opts.call(:from)      { arg[:from].tap { |from_clause| pipe_cte_with!(from_clause) } }
+              lean_opts.call(:cast_with) { casting_options(arg[:cast_with]) }
             end
 
             unless except.include?(:values)
@@ -155,9 +154,6 @@ module ActiveRecordExtended
       #   - key: [Symbol or String] (default=[random letter]) What the row clause will be set as.
       #         - This is useful if you would like to add additional mid-level clauses (see mid-level scope example)
       #
-      #   - cast_as_array [boolean] (default=false): Determines if the query should be nested inside an Array() function
-      #     * Will be deprecated in V2.0 in favor of `cast_with` argument
-      #
       #   - cast_with [Symbol or Array of symbols]: Actions to transform your query
       #     * :to_jsonb
       #     * :array
@@ -172,13 +168,13 @@ module ActiveRecordExtended
       #
       # Examples:
       #   subquery = Group.select(:name, :category_id).where("user_id = users.id")
-      #   User.select(:name, email).select_row_to_json(subquery, as: :users_groups, cast_as_array: true)
+      #   User.select(:name, email).select_row_to_json(subquery, as: :users_groups, cast_with: :array)
       #     #=> [<#User name:.., email:.., users_groups: [{ name: .., category_id: .. }, ..]]
       #
       #  - Adding mid-level scopes:
       #
       #   subquery = Group.select(:name, :category_id)
-      #   User.select_row_to_json(subquery, key: :group, cast_as_array: true) do |scope|
+      #   User.select_row_to_json(subquery, key: :group, cast_with: :array) do |scope|
       #     scope.where(group: { name: "Nerd Core" })
       #   end
       #    #=>  ```sql
@@ -252,7 +248,8 @@ module ActiveRecordExtended
       def select_row_to_json(from = nil, **options, &block)
         from.is_a?(Hash) ? options.merge!(from) : options.reverse_merge!(from: from)
         options.compact!
-        raise ArgumentError, "Required to provide a non-nilled from clause" unless options.key?(:from)
+        raise ArgumentError.new("Required to provide a non-nilled from clause") unless options.key?(:from)
+
         JsonChain.new(spawn).row_to_json!(**options, &block)
       end
 
@@ -273,7 +270,7 @@ module ActiveRecordExtended
       #   - Generic example:
       #
       #   subquery = Group.select(:name, :category_id).where("user_id = users.id")
-      #   User.select(:name, email).select_row_to_json(subquery, as: :users_groups, cast_as_array: true)
+      #   User.select(:name, email).select_row_to_json(subquery, as: :users_groups, cast_with: :array)
       #     #=> [<#User name:.., email:.., users_groups: [{ name: .., category_id: .. }, ..]]
       #
       #  - Setting a custom value:

data/lib/active_record_extended/query_methods/select.rb

@@ -52,12 +52,12 @@ module ActiveRecordExtended
         #  #=> SELECT (ARRAY_AGG(DISTINCT members.price)) AS past_purchases, ...
         def process_hash!(hash_of_options, alias_name)
           enforced_options = {
-            cast_with: hash_of_options.delete(:cast_with),
-            order_by:  hash_of_options.delete(:order_by),
-            distinct:  !(!hash_of_options.delete(:distinct)),
+            cast_with: hash_of_options[:cast_with],
+            order_by:  hash_of_options[:order_by],
+            distinct:  !(!hash_of_options[:distinct])
           }
-          query_statement = hash_to_dot_notation(hash_of_options.delete(:__select_statement) || hash_of_options.first)
-          select!(query_statement, alias_name, enforced_options)
+          query_statement = hash_to_dot_notation(hash_of_options[:__select_statement] || hash_of_options.first)
+          select!(query_statement, alias_name, **enforced_options)
         end
 
         # Turn a hash chain into a query statement:
@@ -65,7 +65,7 @@ module ActiveRecordExtended
         def hash_to_dot_notation(column)
           case column
           when Hash, Array
-            column.to_a.flat_map(&method(:hash_to_dot_notation)).join(".")
+            column.to_a.flat_map { |col| hash_to_dot_notation(col) }.join(".")
           when String, Symbol
             /^([[:alpha:]]+)$/.match?(column.to_s) ? double_quote(column) : column
           else
@@ -76,7 +76,7 @@ module ActiveRecordExtended
         # Add's select statement values to the current relation, select statement lists
         def select!(query, alias_name = nil, **options)
           pipe_cte_with!(query)
-          @scope._select!(to_casted_query(query, alias_name, options))
+          @scope._select!(to_casted_query(query, alias_name, **options))
         end
 
         # Wraps the query with the requested query method
@@ -84,15 +84,15 @@ module ActiveRecordExtended
         #   to_casted_query("memberships.cost", :total_revenue, :sum)
         #    #=> SELECT (SUM(memberships.cost)) AS total_revenue
         def to_casted_query(query, alias_name, **options)
-          cast_with  = options.delete(:cast_with).to_s.downcase
-          order_expr = order_by_expression(options.delete(:order_by))
-          distinct   = cast_with.chomp!("_distinct") || options.delete(:distinct) # account for [:agg_name:]_distinct
+          cast_with  = options[:cast_with].to_s.downcase
+          order_expr = order_by_expression(options[:order_by])
+          distinct   = cast_with.chomp!("_distinct") || options[:distinct] # account for [:agg_name:]_distinct
 
           case cast_with
           when "array", "true"
             wrap_with_array(query, alias_name)
           when AGGREGATE_ONE_LINERS
-            expr         = to_sql_array(query, &method(:group_when_needed))
+            expr         = to_sql_array(query) { |value| group_when_needed(value) }
             casted_query = ::Arel::Nodes::AggregateFunctionName.new(cast_with, expr, distinct).order_by(order_expr)
             nested_alias_escape(casted_query, alias_name)
           else
@@ -102,7 +102,8 @@ module ActiveRecordExtended
       end
 
       def foster_select(*args)
-        raise ArgumentError, "Call `.forster_select' with at least one field" if args.empty?
+        raise ArgumentError.new("Call `.forster_select' with at least one field") if args.empty?
+
         spawn._foster_select!(*args)
       end
 

data/lib/active_record_extended/query_methods/unionize.rb

@@ -59,7 +59,7 @@ module ActiveRecordExtended
         protected
 
         def append_union_order!(union_type, args)
-          args.each(&method(:pipe_cte_with!))
+          args.each { |arg| pipe_cte_with!(arg) }
           flatten_scopes       = flatten_to_sql(args)
           @scope.union_values += flatten_scopes
           calculate_union_operation!(union_type, flatten_scopes.size)
@@ -81,7 +81,7 @@ module ActiveRecordExtended
           union_values:          [],
           union_operations:      [],
           union_ordering_values: [],
-          unionized_name:        nil,
+          unionized_name:        nil
         }
       end
 
@@ -89,10 +89,11 @@ module ActiveRecordExtended
         union_values:          Array,
         union_operations:      Array,
         union_ordering_values: Array,
-        unionized_name:        lambda { |klass| klass.arel_table.name },
+        unionized_name:        lambda { |klass| klass.arel_table.name }
       }.each_pair do |method_name, default|
         define_method(method_name) do
           return unionize_storage[method_name] if send("#{method_name}?")
+
           (default.is_a?(Proc) ? default.call(@klass) : default.new)
         end
 
@@ -106,19 +107,21 @@ module ActiveRecordExtended
       end
 
       def union(opts = :chain, *args)
-        return UnionChain.new(spawn) if opts == :chain
+        return UnionChain.new(spawn) if :chain == opts
+
         opts.nil? ? self : spawn.union!(opts, *args, chain_method: __callee__)
       end
 
       (UNIONIZE_METHODS + UNION_RELATION_METHODS).each do |union_method|
         next if union_method == :union
+
         alias_method union_method, :union
       end
 
       def union!(opts = :chain, *args, chain_method: :union)
         union_chain    = UnionChain.new(self)
         chain_method ||= :union
-        return union_chain if opts == :chain
+        return union_chain if :chain == opts
 
         union_chain.public_send(chain_method, *([opts] + args))
       end
@@ -126,11 +129,13 @@ module ActiveRecordExtended
       # Will construct *Just* the union SQL statement that was been built thus far
       def to_union_sql
         return unless union_values?
+
         apply_union_ordering(build_union_nodes!(false)).to_sql
       end
 
       def to_nice_union_sql(color = true)
         return to_union_sql unless defined?(::Niceql)
+
         ::Niceql::Prettifier.prettify_sql(to_union_sql, color)
       end
 
@@ -172,7 +177,7 @@ module ActiveRecordExtended
 
       def build_union_nodes!(raise_error = true)
         unionize_error_or_warn!(raise_error)
-        union_values.each_with_index.inject(nil) do |union_node, (relation_node, index)|
+        union_values.each_with_index.reduce(nil) do |union_node, (relation_node, index)|
           next resolve_relation_node(relation_node) if union_node.nil?
 
           operation = union_operations.fetch(index - 1, :union)
@@ -215,6 +220,7 @@ module ActiveRecordExtended
       #
       def apply_union_ordering(union_nodes)
         return union_nodes unless union_ordering_values?
+
         UnionChain.new(self).inline_order_by(union_nodes, union_ordering_values)
       end
 
@@ -222,7 +228,7 @@ module ActiveRecordExtended
 
       def unionize_error_or_warn!(raise_error = true)
         if raise_error && union_values.size <= 1
-          raise ArgumentError, "You are required to provide 2 or more unions to join!"
+          raise ArgumentError.new("You are required to provide 2 or more unions to join!")
         elsif !raise_error && union_values.size <= 1
           warn("Warning: You are required to provide 2 or more unions to join.")
         end

data/lib/active_record_extended/query_methods/where_chain.rb

@@ -2,12 +2,15 @@
 
 module ActiveRecordExtended
   module WhereChain
+    AR_VERSION_AT_LEAST_6_1 = ActiveRecord.version >= Gem::Version.new('6.1')
+
     # Finds Records that have an array column that contain any a set of values
     # User.where.overlap(tags: [1,2])
     #   # SELECT * FROM users WHERE tags && {1,2}
-    def overlap(opts, *rest)
-      substitute_comparisons(opts, rest, Arel::Nodes::Overlap, "overlap")
+    def overlaps(opts, *rest)
+      substitute_comparisons(opts, rest, Arel::Nodes::Overlaps, "overlap")
     end
+    alias overlap overlaps
 
     # Finds Records that contain an element in an array column
     # User.where.any(tags: 3)
@@ -54,10 +57,10 @@ module ActiveRecordExtended
           elsif column.try(:array)
             Arel::Nodes::ContainsArray.new(arel.left, arel.right)
           else
-            raise ArgumentError, "Invalid argument for .where.contains(), got #{arel.class}"
+            raise ArgumentError.new("Invalid argument for .where.contains(), got #{arel.class}")
           end
         else
-          raise ArgumentError, "Invalid argument for .where.contains(), got #{arel.class}"
+          raise ArgumentError.new("Invalid argument for .where.contains(), got #{arel.class}")
         end
       end
     end
@@ -88,7 +91,7 @@ module ActiveRecordExtended
         when Arel::Nodes::Equality
           Arel::Nodes::Equality.new(arel.right, Arel::Nodes::NamedFunction.new(function_name, [arel.left]))
         else
-          raise ArgumentError, "Invalid argument for .where.#{function_name.downcase}(), got #{arel.class}"
+          raise ArgumentError.new("Invalid argument for .where.#{function_name.downcase}(), got #{arel.class}")
         end
       end
     end
@@ -99,10 +102,18 @@ module ActiveRecordExtended
         when Arel::Nodes::In, Arel::Nodes::Equality
           arel_node_class.new(arel.left, arel.right)
         else
-          raise ArgumentError, "Invalid argument for .where.#{method}(), got #{arel.class}"
+          raise ArgumentError.new("Invalid argument for .where.#{method}(), got #{arel.class}")
         end
       end
     end
+
+    def build_where_clause_for(scope, opts, rest)
+      if AR_VERSION_AT_LEAST_6_1
+        scope.send(:build_where_clause, opts, rest)
+      else
+        scope.send(:where_clause_factory).build(opts, rest)
+      end
+    end
   end
 end
 
@@ -112,9 +123,9 @@ module ActiveRecord
       prepend ActiveRecordExtended::WhereChain
 
       def build_where_chain(opts, rest, &block)
-        where_clause = @scope.send(:where_clause_factory).build(opts, rest)
+        where_clause = build_where_clause_for(@scope, opts, rest)
         @scope.tap do |scope|
-          scope.references!(PredicateBuilder.references(opts)) if opts.is_a?(Hash)
+          scope.references!(PredicateBuilder.references(opts.stringify_keys)) if opts.is_a?(Hash)
           scope.where_clause += where_clause.modified_predicates(&block)
         end
       end

data/lib/active_record_extended/query_methods/window.rb

@@ -16,7 +16,7 @@ module ActiveRecordExtended
           @scope.window_values! << {
             window_name:  to_arel_sql(@window_name),
             partition_by: flatten_to_sql(partitions),
-            order_by:     order_by_expression(order_by),
+            order_by:     order_by_expression(order_by)
           }
 
           @scope
@@ -81,8 +81,9 @@ module ActiveRecordExtended
 
       def build_windows(arel)
         window_values.each do |window_value|
-          window = arel.window(window_value[:window_name]).partition(window_value[:partition_by])
-          window.order(window_value[:order_by]) if window_value[:order_by]
+          window = arel.window(window_value[:window_name])
+          window = window.partition(window_value[:partition_by]) if window_value[:partition_by].present?
+          window.order(window_value[:order_by])                  if window_value[:order_by]
         end
       end
     end