Fix array join condition for new rails versions

Author: Carlos Silva

gemfiles/Gemfile.rails-5.2

@@ -1,6 +1,6 @@
 source 'https://rubygems.org'
 
-gem 'rails', '~> 5.2.2'
+gem 'rails', '~> 5.2.4'
 gem 'pg', '~> 1.1.3'
 gem "byebug"
 

lib/torque/postgresql/associations/association_scope.rb

@@ -20,6 +20,7 @@ def last_chain_scope(scope, *args)
             # 5.2 reflection, owner
 
             reflection = args.size.eql?(2) ? args[0] : args[1]
+            puts reflection.connected_through_array?.inspect
             return super unless reflection.connected_through_array?
 
             table = args[0] if args.size > 2

lib/torque/postgresql/auxiliary_statement.rb

@@ -205,9 +205,16 @@ def build_join(base)
             end
 
             # Add the scopes defined by the reflection
+            # Possibilities:
+            # table
+            # table, foreign_klass
+            # table, foreign_table, foreign_klass
             if association.respond_to?(:join_scope)
-              args = [@query.arel_table]
-              args << base if association.method(:join_scope).arity.eql?(2)
+              arity = association.method(:join_scope).arity
+              args = [@query.arel_table, foreign_table, base]
+              args.delete_at(1) if arity <= 2 # Delete foreign_table
+              args.delete_at(1) if arity <= 1 # Delete base (foreign_klass)
+
               @query.merge(association.join_scope(*args))
             end
 

lib/torque/postgresql/config.rb

@@ -4,6 +4,7 @@ module PostgreSQL
 
     # Stores a version check for compatibility purposes
     AR521 = (ActiveRecord.gem_version >= Gem::Version.new('5.2.1'))
+    AR523 = (ActiveRecord.gem_version >= Gem::Version.new('5.2.3'))
 
     # Use the same logger as the Active Record one
     def self.logger

lib/torque/postgresql/reflection/abstract_reflection.rb

@@ -17,12 +17,28 @@ def torque_join_keys
           method(:join_keys).arity.eql?(0) ? join_keys : join_keys(klass)
         end
 
+        # Fix for rails 5.2.3 where the join_scope method is the one now
+        # responsible for building the join condition
+        if Torque::PostgreSQL::AR523
+          def join_scope(table, foreign_table, foreign_klass)
+            return super unless connected_through_array?
+
+            predicate_builder = predicate_builder(table)
+            scope_chain_items = join_scopes(table, predicate_builder)
+            klass_scope       = klass_join_scope(table, predicate_builder)
+
+            klass_scope.where!(build_id_constraint_between(table, foreign_table))
+            klass_scope.where!(type => foreign_klass.polymorphic_name) if type
+            klass_scope.where!(klass.send(:type_condition, table)) \
+              if klass.finder_needs_type_condition?
+
+            scope_chain_items.inject(klass_scope, &:merge!)
+          end
+        end
+
         # Manually build the join constraint
         def build_join_constraint(table, foreign_table)
-          klass_attr = table[torque_join_keys.key.to_s]
-          source_attr = foreign_table[torque_join_keys.foreign_key.to_s]
-
-          result = build_id_constraint(klass_attr, source_attr)
+          result = build_id_constraint_between(table, foreign_table)
           result = table.create_and([result, klass.send(:type_condition, table)]) \
             if klass.finder_needs_type_condition?
 
@@ -61,6 +77,13 @@ def build_id_constraint(klass_attr, source_attr)
 
         private
 
+          def build_id_constraint_between(table, foreign_table)
+            klass_attr  = table[torque_join_keys.key.to_s]
+            source_attr = foreign_table[torque_join_keys.foreign_key.to_s]
+
+            build_id_constraint(klass_attr, source_attr)
+          end
+
           # Prepare a value for an array constraint overlap condition
           def cast_constraint_to_array(type, value, should_cast)
             base_ready = type.try(:array) && value.is_a?(AREL_ATTR)