active_record_extended 2.1.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f3f7041cc4869183bc20b38f8387bd8f3f216225990a62ec0c4e0fba5f847dd
-  data.tar.gz: c61e5ad1c2fae32a5dbfe8660bb888d85f255f285a2df8b1f02206f51cbd71b7
+  metadata.gz: b59ef27069d870b734f0494db168936d5536493fd1346469f7a85d9b43bc7655
+  data.tar.gz: f0e25e53250ec9d562bb75ec06e7d02deda48a9996b8a03e4fb5afac2d113abc
 SHA512:
-  metadata.gz: c27cf6541f3e11a3beb00263be7c1478e8f4ddb64b0121ed141347ca995252453864bd3cf0992038b7ea2aa1c409f50792800fdf909d8e544edd470af35231fa
-  data.tar.gz: d0426b00cca79e3d0d145fb87fdd05c25611ff5bfde95c8c1845a281786bd4c7e6bfbd866df46cb8ce1ccd45ab5b4bd91aa83e6c21db879721436574f90087cf
+  metadata.gz: ffad0b652cbaac828d25ed1dbbd6e5e5479f6905bf776785090f9b76fe33fefb750fcbce7c329bbcaf077f1f5401b9817e830d89efab130feca3500bbc97c1f8
+  data.tar.gz: b0f77a0248242cc50e7f87ebd813e90c4e57bf1cfd28e35190ee93fa4ce2ae50878dd6e7f153dc017a692f13d147a9a9f8378ba9583d7705c2b71566fb20e29c

data/README.md

@@ -1,5 +1,5 @@
 [![Gem Version](https://badge.fury.io/rb/active_record_extended.svg)](https://badge.fury.io/rb/active_record_extended)
-[![Build Status](https://travis-ci.com/GeorgeKaraszi/ActiveRecordExtended.svg?branch=master)](https://travis-ci.com/GeorgeKaraszi/ActiveRecordExtended) 
+[![Build Status](https://github.com/GeorgeKaraszi/ActiveRecordExtended/actions/workflows/test.yml/badge.svg?branch=master)](https://github.com/GeorgeKaraszi/ActiveRecordExtended/actions/workflows/test.yml?query=branch%3Amaster+)
 [![Maintainability](https://api.codeclimate.com/v1/badges/98ecffc0239417098cbc/maintainability)](https://codeclimate.com/github/GeorgeKaraszi/active_record_extended/maintainability)
 [![Test Coverage](https://api.codeclimate.com/v1/badges/f22154211bb3a8feb89f/test_coverage)](https://codeclimate.com/github/GeorgeKaraszi/ActiveRecordExtended/test_coverage)
 ## Index
@@ -52,12 +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.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
+ - Minimum Ruby Version: 2.5.x **(EOL warning!)**
+ - Minimum Rails Version: 5.2.x **(EOL warning!)**
+ - Minimum Postgres Version: 10.x **(EOL warning!)**
+ - Latest Ruby supported: 3.1.x
  - Latest Rails supported: 7.0.x
- - Postgres: 9.6-current(13) (probably works with most older versions to a certain point)
+ - Postgres: 10-current(14) (probably works with most older versions to a certain point)
 
 ## Installation
 
@@ -412,12 +412,27 @@ If any or all of your json sub-queries include a CTE, read the [Subquery CTE Got
 #### Row To JSON
 [Postgres 'ROW_TO_JSON' function](https://www.postgresql.org/docs/current/functions-json.html#FUNCTIONS-JSON-CREATION-TABLE)
 
-The implementation of the`.row_to_json/2` method is designed to be used with sub-queries. As a means for taking complex 
+The implementation of the`.select_row_to_json/2` method is designed to be used with sub-queries. As a means for taking complex 
 query logic and transform them into a single or multiple json responses. These responses are required to be assigned 
 to an aliased column on the parent(callee) level.
 
 While quite the mouthful of an explanation. The implementation of combining unrelated or semi-related queries is quite smooth(imo).
 
+**Arguments:**
+  - `from` [String, Arel, or ActiveRecord::Relation]: A subquery that can be nested into a `ROW_TO_JSON` clause
+
+**Options:**
+  - `as` [Symbol or String] (default="results"): What the column will be aliased to
+  - `key` [Symbol or String] (default=[random letter]): Internal query alias name.
+    * This is useful if you would like to add additional mid-level predicate clauses
+  - `cast_with` [Symbol or Array\<Symbol>]:
+    * `:to_jsonb`
+    * `:array`
+    * `:array_agg`
+    * `:distinct`  (auto applies `:array_agg` & `:to_jsonb`)
+  - `order_by` [Symbol or Hash]: Applies an ordering operation (similar to ActiveRecord #order)
+    * **Note**: this option will be ignored if you need to order a DISTINCT Aggregated Array.
+
 ```ruby
     physical_cat  = Category.create!(name: "Physical")
     products      = 3.times.map { Product.create! }

data/lib/active_record_extended/arel/nodes.rb

@@ -5,7 +5,7 @@ require "arel/nodes/function"
 
 module Arel
   module Nodes
-    if Gem::Requirement.new("< 6.1").satisfied_by?(ActiveRecord.gem_version)
+    unless ActiveRecordExtended::AR_VERSION_GTE_6_1
       ["Contains", "Overlaps"].each { |binary_node_name| const_set(binary_node_name, Class.new(::Arel::Nodes::Binary)) }
     end
 

data/lib/active_record_extended/arel/{sql_literal.rb → sql_literal_patch.rb}

@@ -5,7 +5,7 @@ require "arel/nodes/sql_literal"
 # CTE alias fix for Rails 6.1
 module Arel
   module Nodes
-    module SqlLiteralDecorator
+    module SqlLiteralPatch
       def name
         self
       end
@@ -13,4 +13,4 @@ module Arel
   end
 end
 
-Arel::Nodes::SqlLiteral.prepend(Arel::Nodes::SqlLiteralDecorator)
+Arel::Nodes::SqlLiteral.prepend(Arel::Nodes::SqlLiteralPatch)

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

@@ -9,21 +9,25 @@ module ActiveRecordExtended
 
       # rubocop:disable Naming/MethodName
 
-      def visit_Arel_Nodes_Overlaps(object, collector)
-        infix_value object, collector, " && "
+      unless ActiveRecordExtended::AR_VERSION_GTE_6_1
+        def visit_Arel_Nodes_Overlaps(object, collector)
+          infix_value object, collector, " && "
+        end
       end
 
-      def visit_Arel_Nodes_Contains(object, collector)
-        left_column = object.left.relation.name.classify.constantize.columns.detect do |col|
-          matchable_column?(col, object)
-        end
+      unless ActiveRecordExtended::AR_VERSION_GTE_6_1
+        def visit_Arel_Nodes_Contains(object, collector)
+          left_column = object.left.relation.name.classify.constantize.columns.detect do |col|
+            matchable_column?(col, object)
+          end
 
-        if [:hstore, :jsonb].include?(left_column&.type)
-          visit_Arel_Nodes_ContainsHStore(object, collector)
-        elsif left_column.try(:array)
-          visit_Arel_Nodes_ContainsArray(object, collector)
-        else
-          visit_Arel_Nodes_Inet_Contains(object, collector)
+          if [:hstore, :jsonb].include?(left_column&.type)
+            visit_Arel_Nodes_ContainsHStore(object, collector)
+          elsif left_column.try(:array)
+            visit_Arel_Nodes_ContainsArray(object, collector)
+          else
+            visit_Arel_Nodes_Inet_Contains(object, collector)
+          end
         end
       end
 

data/lib/active_record_extended/arel.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "active_record_extended/arel/nodes"
-require "active_record_extended/arel/sql_literal"
+require "active_record_extended/arel/sql_literal_patch"
 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/patch/array_handler_patch.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "active_record/relation/predicate_builder"
+require "active_record/relation/predicate_builder/array_handler"
+
+module ActiveRecordExtended
+  module Patch
+    module ArrayHandlerPatch
+      def call(attribute, value)
+        cache = ActiveRecord::Base.connection.schema_cache
+        if cache.data_source_exists?(attribute.relation.name)
+          column = cache.columns(attribute.relation.name).detect { |col| col.name.to_s == attribute.name.to_s }
+          return attribute.eq(value) if column.try(:array)
+        end
+
+        super(attribute, value)
+      end
+    end
+  end
+end
+
+ActiveRecord::PredicateBuilder::ArrayHandler.prepend(ActiveRecordExtended::Patch::ArrayHandlerPatch)

data/lib/active_record_extended/patch/relation_patch.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module ActiveRecordExtended
+  module Patch
+    module RelationPatch
+      module QueryDelegation
+        AR_EX_QUERY_METHODS = (
+          [
+            :with, :define_window, :select_window, :foster_select,
+            :either_join, :either_joins, :either_order, :either_orders
+          ] +
+          ActiveRecordExtended::QueryMethods::Unionize::UNIONIZE_METHODS +
+          ActiveRecordExtended::QueryMethods::Json::JSON_QUERY_METHODS
+        ).freeze
+
+        delegate(*AR_EX_QUERY_METHODS, to: :all)
+      end
+
+      module Merger
+        def merge
+          merge_ctes!
+          merge_union!
+          merge_windows!
+          super
+        end
+
+        def merge_union!
+          return if other.unionize_storage.empty?
+
+          relation.union_values          += other.union_values
+          relation.union_operations      += other.union_operations
+          relation.union_ordering_values += other.union_ordering_values
+        end
+
+        def merge_windows!
+          return unless other.window_values?
+
+          relation.window_values |= other.window_values
+        end
+
+        def merge_ctes!
+          return unless other.with_values?
+
+          if other.recursive_value? && !relation.recursive_value?
+            relation.with!.recursive(other.cte)
+          else
+            relation.with!(other.cte)
+          end
+        end
+      end
+
+      module ArelBuildPatch
+        def build_arel(*aliases)
+          super.tap do |arel|
+            build_windows(arel) if window_values?
+            build_unions(arel)  if union_values?
+            build_with(arel)    if with_values?
+          end
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Relation.prepend(ActiveRecordExtended::Patch::RelationPatch::ArelBuildPatch)
+ActiveRecord::Relation::Merger.prepend(ActiveRecordExtended::Patch::RelationPatch::Merger)
+ActiveRecord::Base.extend(ActiveRecordExtended::Patch::RelationPatch::QueryDelegation)

data/lib/active_record_extended/patch/where_clause_patch.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActiveRecordExtended
+  module Patch
+    module WhereClausePatch
+      def modified_predicates(&block)
+        ActiveRecord::Relation::WhereClause.new(predicates.map(&block))
+      end
+    end
+  end
+end
+
+ActiveRecord::Relation::WhereClause.prepend(ActiveRecordExtended::Patch::WhereClausePatch)

data/lib/active_record_extended/query_methods/any_of.rb

@@ -29,7 +29,7 @@ module ActiveRecordExtended
 
       def hash_map_queries(queries)
         if queries.size == 1 && queries.first.is_a?(Hash)
-          queries.first.each_pair.map { |attr, predicate| Hash[attr, predicate] }
+          queries.first.each_pair.map { |attr, predicate| { attr => predicate } }
         else
           queries
         end

data/lib/active_record_extended/query_methods/either.rb

@@ -26,7 +26,7 @@ module ActiveRecordExtended
       private
 
       def xor_field_sql(options)
-        XOR_FIELD_SQL % Hash[xor_field_options(options)]
+        XOR_FIELD_SQL % xor_field_options(options).to_h
       end
 
       def sort_order_sql(dir)
@@ -35,7 +35,7 @@ module ActiveRecordExtended
 
       def xor_field_options(options)
         str_args = options.flatten.take(XOR_FIELD_KEYS.size).map(&:to_s)
-        Hash[XOR_FIELD_KEYS.zip(str_args)]
+        XOR_FIELD_KEYS.zip(str_args).to_h
       end
 
       def map_columns_to_tables(associations_and_columns)
@@ -60,4 +60,4 @@ module ActiveRecordExtended
   end
 end
 
-ActiveRecord::Base.extend(ActiveRecordExtended::QueryMethods::Either)
+ActiveRecord::Relation.prepend(ActiveRecordExtended::QueryMethods::Either)

data/lib/active_record_extended/query_methods/{select.rb → foster_select.rb}

@@ -2,10 +2,10 @@
 
 module ActiveRecordExtended
   module QueryMethods
-    module Select
+    module FosterSelect
       class SelectHelper
-        include ::ActiveRecordExtended::Utilities::Support
-        include ::ActiveRecordExtended::Utilities::OrderBy
+        include ActiveRecordExtended::Utilities::Support
+        include ActiveRecordExtended::Utilities::OrderBy
 
         AGGREGATE_ONE_LINERS = /^(exists|sum|max|min|avg|count|jsonb?_agg|(bit|bool)_(and|or)|xmlagg|array_agg)$/.freeze
 
@@ -115,4 +115,4 @@ module ActiveRecordExtended
   end
 end
 
-ActiveRecord::Relation.prepend(ActiveRecordExtended::QueryMethods::Select)
+ActiveRecord::Relation.prepend(ActiveRecordExtended::QueryMethods::FosterSelect)

data/lib/active_record_extended/query_methods/json.rb

@@ -12,8 +12,8 @@ module ActiveRecordExtended
       ].freeze
 
       class JsonChain
-        include ::ActiveRecordExtended::Utilities::Support
-        include ::ActiveRecordExtended::Utilities::OrderBy
+        include ActiveRecordExtended::Utilities::Support
+        include ActiveRecordExtended::Utilities::OrderBy
 
         DEFAULT_ALIAS    = '"results"'
         TO_JSONB_OPTIONS = [:array_agg, :distinct, :to_jsonb].to_set.freeze

data/lib/active_record_extended/query_methods/unionize.rb

@@ -7,8 +7,8 @@ module ActiveRecordExtended
       UNIONIZE_METHODS       = [:union, :union_all, :union_except, :union_intersect].freeze
 
       class UnionChain
-        include ::ActiveRecordExtended::Utilities::Support
-        include ::ActiveRecordExtended::Utilities::OrderBy
+        include ActiveRecordExtended::Utilities::Support
+        include ActiveRecordExtended::Utilities::OrderBy
 
         def initialize(scope)
           @scope = scope
@@ -107,7 +107,7 @@ module ActiveRecordExtended
       end
 
       def union(opts = :chain, *args)
-        return UnionChain.new(spawn) if :chain == opts
+        return UnionChain.new(spawn) if opts == :chain
 
         opts.nil? ? self : spawn.union!(opts, *args, chain_method: __callee__)
       end
@@ -121,7 +121,7 @@ module ActiveRecordExtended
       def union!(opts = :chain, *args, chain_method: :union)
         union_chain    = UnionChain.new(self)
         chain_method ||= :union
-        return union_chain if :chain == opts
+        return union_chain if opts == :chain
 
         union_chain.public_send(chain_method, *([opts] + args))
       end
@@ -178,7 +178,7 @@ module ActiveRecordExtended
       def build_union_nodes!(raise_error = true)
         unionize_error_or_warn!(raise_error)
         union_values.each_with_index.reduce(nil) do |union_node, (relation_node, index)|
-          next resolve_relation_node(relation_node) if union_node.nil?
+          next resolve_relation_node(relation_node) if union_node.nil? # rubocop:disable Lint/UnmodifiedReduceAccumulator
 
           operation = union_operations.fetch(index - 1, :union)
           left      = union_node

data/lib/active_record_extended/query_methods/where_chain.rb

@@ -1,117 +1,121 @@
 # frozen_string_literal: true
 
 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 overlaps(opts, *rest)
-      substitute_comparisons(opts, rest, Arel::Nodes::Overlaps, "overlap")
-    end
-    alias overlap overlaps
+  module QueryMethods
+    module WhereChain
+      # 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 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)
-    #   # SELECT user.* FROM user WHERE 3 = ANY(user.tags)
-    def any(opts, *rest)
-      equality_to_function("ANY", opts, rest)
-    end
+      # Finds Records that contain an element in an array column
+      # User.where.any(tags: 3)
+      #   # SELECT user.* FROM user WHERE 3 = ANY(user.tags)
+      def any(opts, *rest)
+        equality_to_function("ANY", opts, rest)
+      end
 
-    # Finds Records that contain a single matchable array element
-    # User.where.all(tags: 3)
-    #   # SELECT user.* FROM user WHERE 3 = ALL(user.tags)
-    def all(opts, *rest)
-      equality_to_function("ALL", opts, rest)
-    end
+      # Finds Records that contain a single matchable array element
+      # User.where.all(tags: 3)
+      #   # SELECT user.* FROM user WHERE 3 = ALL(user.tags)
+      def all(opts, *rest)
+        equality_to_function("ALL", opts, rest)
+      end
 
-    # Finds Records that contains a nested set elements
-    #
-    # Array Column Type:
-    #   User.where.contains(tags: [1, 3])
-    #   # SELECT user.* FROM user WHERE user.tags @> {1,3}
-    #
-    # HStore Column Type:
-    #   User.where.contains(data: { nickname: 'chainer' })
-    #   # SELECT user.* FROM user WHERE user.data @> 'nickname' => 'chainer'
-    #
-    # JSONB Column Type:
-    #   User.where.contains(data: { nickname: 'chainer' })
-    #   # SELECT user.* FROM user WHERE user.data @> {'nickname': 'chainer'}
-    #
-    # This can also be used along side joined tables
-    #
-    # JSONB Column Type Example:
-    #   Tag.joins(:user).where.contains(user: { data: { nickname: 'chainer' } })
-    #   # SELECT tags.* FROM tags INNER JOIN user on user.id = tags.user_id WHERE user.data @> { nickname: 'chainer' }
-    #
-    def contains(opts, *rest)
-      build_where_chain(opts, rest) do |arel|
-        case arel
-        when Arel::Nodes::In, Arel::Nodes::Equality
-          column = left_column(arel) || column_from_association(arel)
-
-          if [:hstore, :jsonb].include?(column.type)
-            Arel::Nodes::ContainsHStore.new(arel.left, arel.right)
-          elsif column.try(:array)
-            Arel::Nodes::ContainsArray.new(arel.left, arel.right)
+      # Finds Records that contains a nested set elements
+      #
+      # Array Column Type:
+      #   User.where.contains(tags: [1, 3])
+      #   # SELECT user.* FROM user WHERE user.tags @> {1,3}
+      #
+      # HStore Column Type:
+      #   User.where.contains(data: { nickname: 'chainer' })
+      #   # SELECT user.* FROM user WHERE user.data @> 'nickname' => 'chainer'
+      #
+      # JSONB Column Type:
+      #   User.where.contains(data: { nickname: 'chainer' })
+      #   # SELECT user.* FROM user WHERE user.data @> {'nickname': 'chainer'}
+      #
+      # This can also be used along side joined tables
+      #
+      # JSONB Column Type Example:
+      #   Tag.joins(:user).where.contains(user: { data: { nickname: 'chainer' } })
+      #   # SELECT tags.* FROM tags INNER JOIN user on user.id = tags.user_id WHERE user.data @> { nickname: 'chainer' }
+      #
+      def contains(opts, *rest)
+        if ActiveRecordExtended::AR_VERSION_GTE_6_1
+          return substitute_comparisons(opts, rest, Arel::Nodes::Contains, "contains")
+        end
+
+        build_where_chain(opts, rest) do |arel|
+          case arel
+          when Arel::Nodes::In, Arel::Nodes::Equality
+            column = left_column(arel) || column_from_association(arel)
+
+            if [:hstore, :jsonb].include?(column.type)
+              Arel::Nodes::ContainsHStore.new(arel.left, arel.right)
+            elsif column.try(:array)
+              Arel::Nodes::ContainsArray.new(arel.left, arel.right)
+            else
+              raise ArgumentError.new("Invalid argument for .where.contains(), got #{arel.class}")
+            end
           else
             raise ArgumentError.new("Invalid argument for .where.contains(), got #{arel.class}")
           end
-        else
-          raise ArgumentError.new("Invalid argument for .where.contains(), got #{arel.class}")
         end
       end
-    end
 
-    private
+      private
 
-    def matchable_column?(col, arel)
-      col.name == arel.left.name.to_s || col.name == arel.left.relation.name.to_s
-    end
+      def matchable_column?(col, arel)
+        col.name == arel.left.name.to_s || col.name == arel.left.relation.name.to_s
+      end
 
-    def column_from_association(arel)
-      assoc = assoc_from_related_table(arel)
-      assoc.klass.columns.detect { |col| matchable_column?(col, arel) } if assoc
-    end
+      def column_from_association(arel)
+        assoc = assoc_from_related_table(arel)
+        assoc.klass.columns.detect { |col| matchable_column?(col, arel) } if assoc
+      end
 
-    def assoc_from_related_table(arel)
-      @scope.klass.reflect_on_association(arel.left.relation.name.to_sym) ||
-        @scope.klass.reflect_on_association(arel.left.relation.name.singularize.to_sym)
-    end
+      def assoc_from_related_table(arel)
+        @scope.klass.reflect_on_association(arel.left.relation.name.to_sym) ||
+          @scope.klass.reflect_on_association(arel.left.relation.name.singularize.to_sym)
+      end
 
-    def left_column(arel)
-      @scope.klass.columns_hash[arel.left.name] || @scope.klass.columns_hash[arel.left.relation.name]
-    end
+      def left_column(arel)
+        @scope.klass.columns_hash[arel.left.name] || @scope.klass.columns_hash[arel.left.relation.name]
+      end
 
-    def equality_to_function(function_name, opts, rest)
-      build_where_chain(opts, rest) do |arel|
-        case arel
-        when Arel::Nodes::Equality
-          Arel::Nodes::Equality.new(arel.right, Arel::Nodes::NamedFunction.new(function_name, [arel.left]))
-        else
-          raise ArgumentError.new("Invalid argument for .where.#{function_name.downcase}(), got #{arel.class}")
+      def equality_to_function(function_name, opts, rest)
+        build_where_chain(opts, rest) do |arel|
+          case arel
+          when Arel::Nodes::Equality
+            Arel::Nodes::Equality.new(arel.right, Arel::Nodes::NamedFunction.new(function_name, [arel.left]))
+          else
+            raise ArgumentError.new("Invalid argument for .where.#{function_name.downcase}(), got #{arel.class}")
+          end
         end
       end
-    end
 
-    def substitute_comparisons(opts, rest, arel_node_class, method)
-      build_where_chain(opts, rest) do |arel|
-        case arel
-        when Arel::Nodes::In, Arel::Nodes::Equality
-          arel_node_class.new(arel.left, arel.right)
-        else
-          raise ArgumentError.new("Invalid argument for .where.#{method}(), got #{arel.class}")
+      def substitute_comparisons(opts, rest, arel_node_class, method)
+        build_where_chain(opts, rest) do |arel|
+          case arel
+          when Arel::Nodes::In, Arel::Nodes::Equality
+            arel_node_class.new(arel.left, arel.right)
+          else
+            raise ArgumentError.new("Invalid argument for .where.#{method}(), got #{arel.class}")
+          end
         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)
+      def build_where_clause_for(scope, opts, rest)
+        if ActiveRecordExtended::AR_VERSION_GTE_6_1
+          scope.send(:build_where_clause, opts, rest)
+        else
+          scope.send(:where_clause_factory).build(opts, rest)
+        end
       end
     end
   end
@@ -120,7 +124,7 @@ end
 module ActiveRecord
   module QueryMethods
     class WhereChain
-      prepend ActiveRecordExtended::WhereChain
+      prepend ActiveRecordExtended::QueryMethods::WhereChain
 
       def build_where_chain(opts, rest, &block)
         where_clause = build_where_clause_for(@scope, opts, rest)

data/lib/active_record_extended/query_methods/window.rb

@@ -4,8 +4,8 @@ module ActiveRecordExtended
   module QueryMethods
     module Window
       class DefineWindowChain
-        include ::ActiveRecordExtended::Utilities::Support
-        include ::ActiveRecordExtended::Utilities::OrderBy
+        include ActiveRecordExtended::Utilities::Support
+        include ActiveRecordExtended::Utilities::OrderBy
 
         def initialize(scope, window_name)
           @scope        = scope
@@ -24,7 +24,7 @@ module ActiveRecordExtended
       end
 
       class WindowSelectBuilder
-        include ::ActiveRecordExtended::Utilities::Support
+        include ActiveRecordExtended::Utilities::Support
 
         def initialize(window_function, args, window_name)
           @window_function = window_function

data/lib/active_record_extended/query_methods/with_cte.rb

@@ -4,7 +4,7 @@ module ActiveRecordExtended
   module QueryMethods
     module WithCTE
       class WithCTE
-        include ::ActiveRecordExtended::Utilities::Support
+        include ActiveRecordExtended::Utilities::Support
         include Enumerable
         extend  Forwardable
 
@@ -113,14 +113,14 @@ module ActiveRecordExtended
 
       # @param [Hash, WithCTE] opts
       def with(opts = :chain, *rest)
-        return WithChain.new(spawn) if :chain == opts
+        return WithChain.new(spawn) if opts == :chain
 
         opts.blank? ? self : spawn.with!(opts, *rest)
       end
 
       # @param [Hash, WithCTE] opts
       def with!(opts = :chain, *_rest)
-        return WithChain.new(self) if :chain == opts
+        return WithChain.new(self) if opts == :chain
 
         tap do |scope|
           scope.cte ||= WithCTE.new(self)

data/lib/active_record_extended/utilities/order_by.rb

@@ -49,7 +49,7 @@ module ActiveRecordExtended
               obj.each_pair do |o_key, o_value|
                 new_hash["#{tbl_or_col}.#{o_key}"] = o_value
               end
-            elsif ::ActiveRecord::QueryMethods::VALID_DIRECTIONS.include?(obj)
+            elsif ActiveRecord::QueryMethods::VALID_DIRECTIONS.include?(obj)
               new_hash[tbl_or_col] = obj
             elsif obj.nil?
               new_hash[tbl_or_col.to_s] = :asc

data/lib/active_record_extended/utilities/support.rb

@@ -113,7 +113,7 @@ module ActiveRecordExtended
         case value.to_s
           # Ignore keys that contain double quotes or a Arel.star (*)[all columns]
           # or if a table has already been explicitly declared (ex: users.id)
-        when "*", /((^".+"$)|(^[[:alpha:]]+\.[[:alnum:]]+))/
+        when "*", /((^".+"$)|(^[[:alpha:]]+\.[[:alnum:]]+)|\(.+\))/
           value
         else
           PG::Connection.quote_ident(value.to_s)