torque-postgresql 1.1.7 → 2.0.4

data/lib/torque/postgresql/arel/join_source.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Torque
   module PostgreSQL
     module Arel

data/lib/torque/postgresql/arel/nodes.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Torque
   module PostgreSQL
     module Arel

data/lib/torque/postgresql/arel/operations.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Torque
   module PostgreSQL
     module Arel

data/lib/torque/postgresql/arel/select_manager.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Torque
   module PostgreSQL
     module Arel

data/lib/torque/postgresql/arel/visitors.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module Torque
   module PostgreSQL
     module Arel
       module Visitors
         # Enclose select manager with parenthesis
         # :TODO: Remove when checking the new version of Arel
-        def visit_Arel_SelectManager o, collector
+        def visit_Arel_SelectManager(o, collector)
           collector << '('
           visit(o.ast, collector) << ')'
         end
@@ -23,8 +25,9 @@ module Torque
 
         # Allow quoted arrays to get here
         def visit_Arel_Nodes_Casted(o, collector)
-          return super unless o.val.is_a?(::Enumerable)
-          quote_array(o.val, collector)
+          value = o.respond_to?(:val) ? o.val : o.value
+          return super unless value.is_a?(::Enumerable)
+          quote_array(value, collector)
         end
 
         ## TORQUE VISITORS

data/lib/torque/postgresql/associations.rb

@@ -3,6 +3,3 @@ require_relative 'associations/association_scope'
 require_relative 'associations/belongs_to_many_association'
 require_relative 'associations/builder'
 require_relative 'associations/preloader'
-
-require_relative 'associations/join_dependency/join_association' \
-  unless Torque::PostgreSQL::AR521

data/lib/torque/postgresql/associations/association.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Torque
   module PostgreSQL
     module Associations
@@ -19,12 +21,14 @@ module Torque
             add_id = owner[reflection.active_record_primary_key]
             record_fk = reflection.foreign_key
 
-            record[record_fk].push(add_id) unless (record[record_fk] ||= []).include?(add_id)
+            list = record[record_fk] ||= []
+            list.push(add_id) unless list.include?(add_id)
           end
 
       end
 
       ::ActiveRecord::Associations::Association.prepend(Association)
+      ::ActiveRecord::Associations::HasManyAssociation.prepend(Association)
     end
   end
 end

data/lib/torque/postgresql/associations/association_scope.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Torque
   module PostgreSQL
     module Associations
@@ -14,63 +16,40 @@ module Torque
           # When the relation is connected through an array, intercept the
           # condition builder and uses an overlap condition building it on
           # +build_id_constraint+
-          def last_chain_scope(scope, *args)
-            # 5.0 table, reflection, owner, association_klass
-            # 5.1 table, reflection, owner
-            # 5.2 reflection, owner
-
-            reflection = args.size.eql?(2) ? args[0] : args[1]
+          def last_chain_scope(scope, reflection, owner)
             return super unless reflection.connected_through_array?
 
-            table = args[0] if args.size > 2
-            keys = args.size.eql?(4) ? reflection.join_keys(args[3]) : reflection.join_keys
-            owner = args.size.eql?(2) ? args[1] : args[2]
-
+            keys = reflection.join_keys
             value = transform_value(owner[keys.foreign_key])
-            constraint, binds = build_id_constraint(reflection, keys, value, table, true)
+            constraint = build_id_constraint(reflection, keys, value, true)
 
-            if Torque::PostgreSQL::AR521
-              scope.where!(constraint)
-            else
-              klass = ::ActiveRecord::Relation::WhereClause
-              scope.where_clause += klass.new([constraint], binds)
-              scope
-            end
+            scope.where!(constraint)
           end
 
           # When the relation is connected through an array, intercept the
           # condition builder and uses an overlap condition building it on
           # +build_id_constraint+
-          def next_chain_scope(scope, *args)
-            # 5.0 table, reflection, association_klass, foreign_table, next_reflection
-            # 5.1 table, reflection, foreign_table, next_reflection
-            # 5.2 reflection, next_reflection
-
-            reflection = args.size.eql?(2) ? args[0] : args[1]
+          def next_chain_scope(scope, reflection, next_reflection)
             return super unless reflection.connected_through_array?
 
-            table = args[0] if args.size > 2
-            next_reflection = args[-1]
-
-            foreign_table = args[-2] if args.size.eql?(5)
-            foreign_table ||= next_reflection.aliased_table
-
-            keys = args.size.eql?(5) ? reflection.join_keys(args[2]) : reflection.join_keys
+            keys = reflection.join_keys
+            foreign_table = next_reflection.aliased_table
 
             value = foreign_table[keys.foreign_key]
-            constraint, *_ = build_id_constraint(reflection, keys, value, table)
+            constraint = build_id_constraint(reflection, keys, value)
 
             scope.joins!(join(foreign_table, constraint))
           end
 
           # Trigger the same method on the relation which will build the
           # constraint condition using array logics
-          def build_id_constraint(reflection, keys, value, table = nil, bind_param = false)
-            table ||= reflection.aliased_table
-            value, binds = build_binds_for_constraint(reflection, value, keys.foreign_key) \
-              if bind_param
+          def build_id_constraint(reflection, keys, value, bind_param = false)
+            table = reflection.aliased_table
+            value = Array.wrap(value).map do |value|
+              build_bind_param_for_constraint(reflection, value, keys.foreign_key)
+            end if bind_param
 
-            [reflection.build_id_constraint(table[keys.key], value), binds]
+            reflection.build_id_constraint(table[keys.key], value)
           end
 
           # For array-like values, it needs to call the method as many times as
@@ -83,30 +62,11 @@ module Torque
             end
           end
 
-          # When binds are necessary for a constraint, instantiate them
-          if Torque::PostgreSQL::AR521
-            def build_binds_for_constraint(reflection, values, foreign_key)
-              result = Array.wrap(values).map do |value|
-                ::Arel::Nodes::BindParam.new(::ActiveRecord::Relation::QueryAttribute.new(
-                  foreign_key, value, reflection.klass.attribute_types[foreign_key],
-                ))
-              end
-
-              [result, nil]
-            end
-          else
-            def build_binds_for_constraint(reflection, values, foreign_key)
-              type = reflection.klass.attribute_types[foreign_key]
-              parts = Array.wrap(values).map do |value|
-                bind = ::Arel::Nodes::BindParam.new
-                value = ::ActiveRecord::Relation::QueryAttribute.new(foreign_key, value, type)
-                [bind, value]
-              end.to_h
-
-              [parts.keys, parts.values]
-            end
+          def build_bind_param_for_constraint(reflection, value, foreign_key)
+            ::Arel::Nodes::BindParam.new(::ActiveRecord::Relation::QueryAttribute.new(
+              foreign_key, value, reflection.klass.attribute_types[foreign_key],
+            ))
           end
-
       end
 
       ::ActiveRecord::Associations::AssociationScope.singleton_class.prepend(AssociationScope::ClassMethods)

data/lib/torque/postgresql/associations/belongs_to_many_association.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require 'active_record/associations/collection_association'
+
 # FIXME: build, create
 module Torque
   module PostgreSQL
@@ -33,7 +36,8 @@ module Torque
 
         def ids_writer(new_ids)
           column = source_attr
-          owner.update_column(column, owner[column] = new_ids.presence)
+          command = owner.persisted? ? :update_column : :write_attribute
+          owner.public_send(command, column, new_ids.presence)
           @association_scope = nil
         end
 

data/lib/torque/postgresql/associations/builder/belongs_to_many.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Torque
   module PostgreSQL
     module Associations

data/lib/torque/postgresql/associations/builder/has_many.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Torque
   module PostgreSQL
     module Associations

data/lib/torque/postgresql/associations/preloader.rb

@@ -1,33 +1 @@
 require_relative 'preloader/association'
-
-unless Torque::PostgreSQL::AR521
-  module Torque
-    module PostgreSQL
-      module Associations
-        module Preloader
-          class BelongsToMany < ::ActiveRecord::Associations::Preloader::HasMany
-            def association_key_name
-              reflection.active_record_primary_key
-            end
-
-            def owner_key_name
-              reflection.foreign_key
-            end
-          end
-
-          def preloader_for(reflection, owners, *)
-            return AlreadyLoaded \
-              if owners.first.association(reflection.name).loaded?
-
-            return BelongsToMany \
-              if reflection.macro.eql?(:belongs_to_many)
-
-            super
-          end
-        end
-
-        ::ActiveRecord::Associations::Preloader.prepend(Preloader)
-      end
-    end
-  end
-end

data/lib/torque/postgresql/associations/preloader/association.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Torque
   module PostgreSQL
     module Associations
@@ -8,7 +10,7 @@ module Torque
 
           # For reflections connected through an array, make sure to properly
           # decuple the list of ids and set them as associated with the owner
-          def run(preloader)
+          def run
             return super unless connected_through_array?
             send("run_array_for_#{@reflection.macro}")
           end
@@ -18,7 +20,7 @@ module Torque
             # Specific run for belongs_many association
             def run_array_for_belongs_to_many
               # Add reverse to has_many
-              records = load_records
+              records = groupped_records
               owners.each do |owner|
                 items = records.values_at(*Array.wrap(owner[owner_key_name]))
                 associate_records_to_owner(owner, items.flatten)
@@ -29,7 +31,7 @@ module Torque
             def run_array_for_has_many
               # Add reverse to belongs_to_many
               records = Hash.new { |h, k| h[k] = [] }
-              load_records.each do |ids, record|
+              groupped_records.each do |ids, record|
                 ids.each { |id| records[id].concat(Array.wrap(record)) }
               end
 
@@ -38,23 +40,53 @@ module Torque
               end
             end
 
+            if PostgreSQL::AR610
+            # This is how Rails 6.1 now load the records
+              def load_records
+                return super unless connected_through_array?
+
+                @records_by_owner = {}.compare_by_identity
+                raw_records = owner_keys.empty? ? [] : records_for(owner_keys)
+
+                @preloaded_records = raw_records.select do |record|
+                  assignments = false
+
+                  ids = convert_key(record[association_key_name])
+                  owners_by_key.values_at(*ids).flat_map do |owner|
+                    entries = (@records_by_owner[owner] ||= [])
+
+                    if reflection.collection? || entries.empty?
+                      entries << record
+                      assignments = true
+                    end
+                  end
+
+                  assignments
+                end
+              end
+            end
+
             # Build correctly the constraint condition in order to get the
             # associated ids
             def records_for(ids, &block)
               return super unless connected_through_array?
-              condition = scope.arel_attribute(association_key_name)
+              condition = scope.arel_table[association_key_name]
               condition = reflection.build_id_constraint(condition, ids.flatten.uniq)
               scope.where(condition).load(&block)
             end
 
-            unless Torque::PostgreSQL::AR521
-              def associate_records_to_owner(owner, records)
-                association = owner.association(reflection.name)
-                association.loaded!
-                association.target.concat(records)
-              end
+            def associate_records_to_owner(owner, records)
+              return super unless connected_through_array?
+              association = owner.association(reflection.name)
+              association.loaded!
+              association.target.concat(records)
             end
 
+            def groupped_records
+              preloaded_records.group_by do |record|
+                convert_key(record[association_key_name])
+              end
+            end
         end
 
         ::ActiveRecord::Associations::Preloader::Association.prepend(Association)

data/lib/torque/postgresql/attributes/builder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'builder/enum'
 require_relative 'builder/period'
 

data/lib/torque/postgresql/attributes/builder/enum.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Torque
   module PostgreSQL
     module Attributes
@@ -153,12 +155,12 @@ module Torque
               cast_type = subtype.name.chomp('[]')
               klass_module.module_eval <<-RUBY, __FILE__, __LINE__ + 1
                 def has_#{attribute.pluralize}(*values)                             # def has_roles(*values)
-                  attr = arel_attribute('#{attribute}')                             #   attr = arel_attribute('role')
+                  attr = arel_table['#{attribute}']                                 #   attr = arel_table['role']
                   where(attr.contains(::Arel.array(values, cast: '#{cast_type}')))  #   where(attr.contains(::Arel.array(values, cast: 'roles')))
                 end                                                                 # end
 
                 def has_any_#{attribute.pluralize}(*values)                         # def has_roles(*values)
-                  attr = arel_attribute('#{attribute}')                             #   attr = arel_attribute('role')
+                  attr = arel_table['#{attribute}']                                 #   attr = arel_table['role']
                   where(attr.overlaps(::Arel.array(values, cast: '#{cast_type}')))  #   where(attr.overlaps(::Arel.array(values, cast: 'roles')))
                 end                                                                 # end
               RUBY
@@ -184,7 +186,7 @@ module Torque
               values_methods.each do |key, (scope, ask, bang, val)|
                 klass_content += <<-RUBY
                   def #{scope}                                    # def admin
-                    attr = arel_attribute('#{attribute}')         #   attr = arel_attribute('role')
+                    attr = arel_table['#{attribute}']             #   attr = arel_table['role']
                     where(::#{enum_klass}.scope(attr, '#{val}'))  #   where(Enum::Roles.scope(attr, 'admin'))
                   end                                             # end
                 RUBY

data/lib/torque/postgresql/attributes/builder/period.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Torque
   module PostgreSQL
     module Attributes
@@ -202,7 +204,7 @@ module Torque
             end
 
             def arel_attribute
-              @arel_attribute ||= "arel_attribute(#{attribute.inspect})"
+              @arel_attribute ||= "arel_table[#{attribute.inspect}]"
             end
 
             def arel_default_sql
@@ -245,7 +247,7 @@ module Torque
             def arel_real_start_at
               return arel_start_at unless threshold.present?
               @arel_real_start_at ||= begin
-                result = "(#{arel_start_at} - #{arel_threshold_value})"
+                result = +"(#{arel_start_at} - #{arel_threshold_value})"
                 result << '.cast(:date)' if  type.eql?(:daterange)
                 result
               end
@@ -255,7 +257,7 @@ module Torque
             def arel_real_finish_at
               return arel_finish_at unless threshold.present?
               @arel_real_finish_at ||= begin
-                result = "(#{arel_finish_at} + #{arel_threshold_value})"
+                result = +"(#{arel_finish_at} + #{arel_threshold_value})"
                 result << '.cast(:date)' if  type.eql?(:daterange)
                 result
               end
@@ -276,7 +278,7 @@ module Torque
 
             # Create an arel named function
             def arel_named_function(name, *args)
-              result = "::Arel::Nodes::NamedFunction.new(#{name.to_s.inspect}"
+              result = +"::Arel::Nodes::NamedFunction.new(#{name.to_s.inspect}"
               result << ', [' << args.join(', ') << ']' if args.present?
               result << ')'
             end

data/lib/torque/postgresql/attributes/enum.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Torque
   module PostgreSQL
     module Attributes
@@ -31,11 +33,6 @@ module Torque
             end
           end
 
-          # You can specify the connection name for each enum
-          def connection_specification_name
-            return self == Enum ? 'primary' : superclass.connection_specification_name
-          end
-
           # Overpass new so blank values return only nil
           def new(value)
             return Lazy.new(self, LAZY_VALUE) if value.blank?
@@ -45,9 +42,7 @@ module Torque
           # Load the list of values in a lazy way
           def values
             @values ||= self == Enum ? nil : begin
-              conn_name = connection_specification_name
-              conn = connection(conn_name)
-              conn.enum_values(type_name).freeze
+              connection.enum_values(type_name).freeze
             end
           end
 
@@ -110,8 +105,8 @@ module Torque
             end
 
             # Get a connection based on its name
-            def connection(name)
-              ActiveRecord::Base.connection_handler.retrieve_connection(name)
+            def connection
+              ::ActiveRecord::Base.connection
             end
 
         end