torque-postgresql 1.1.1 → 2.0.1

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

@@ -33,7 +33,8 @@ module Torque
 
         def ids_writer(new_ids)
           column = reflection.active_record_primary_key
-          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/preloader.rb

@@ -1,25 +1 @@
 require_relative 'preloader/association'
-
-unless Torque::PostgreSQL::AR521
-  module Torque
-    module PostgreSQL
-      module Associations
-        module Preloader
-          BelongsToMany = Class.new(::ActiveRecord::Associations::Preloader::HasMany)
-
-          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

@@ -8,7 +8,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 +18,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 +29,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
 
@@ -47,14 +47,18 @@ module Torque
               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/auxiliary_statement.rb

@@ -31,11 +31,12 @@ module Torque
         end
 
         # Fast access to statement build
-        def build(statement, base, options = nil, bound_attributes = [])
+        def build(statement, base, options = nil, bound_attributes = [], join_sources = [])
           klass = instantiate(statement, base, options)
           result = klass.build(base)
 
           bound_attributes.concat(klass.bound_attributes)
+          join_sources.concat(klass.join_sources)
           result
         end
 
@@ -105,7 +106,7 @@ module Torque
       delegate :config, :table, :table_name, :relation, :configure, :relation_query?,
         to: :class
 
-      attr_reader :bound_attributes
+      attr_reader :bound_attributes, :join_sources
 
       # Start a new auxiliary statement giving extra options
       def initialize(*args)
@@ -117,15 +118,21 @@ module Torque
         @where = options.fetch(:where, {})
         @select = options.fetch(:select, {})
         @join_type = options.fetch(:join_type, nil)
+
         @bound_attributes = []
+        @join_sources = []
       end
 
       # Build the statement on the given arel and return the WITH statement
       def build(base)
+        @bound_attributes.clear
+        @join_sources.clear
+
+        # Prepare all the data for the statement
         prepare(base)
 
         # Add the join condition to the list
-        base.joins_values += [build_join(base)]
+        @join_sources << build_join(base)
 
         # Return the statement with its dependencies
         [@dependencies, ::Arel::Nodes::As.new(table, build_query(base))]
@@ -204,19 +211,7 @@ module Torque
               foreign_table = ::Arel::Table.new(association.plural_name)
             end
 
-            # Add the scopes defined by the reflection
-            # Possibilities:
-            # table
-            # table, foreign_klass
-            # table, foreign_table, foreign_klass
-            if association.respond_to?(:join_scope)
-              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
+            @query.merge(association.join_scope(@query.arel_table, foreign_table, base))
 
             # Add the join constraints
             constraint = association.build_join_constraint(table, foreign_table)
@@ -288,7 +283,7 @@ module Torque
               cte.is_a?(dependent_klass)
             end
 
-            AuxiliaryStatement.build(dependent, base, options, bound_attributes)
+            AuxiliaryStatement.build(dependent, base, options, bound_attributes, join_sources)
           end
         end
 

data/lib/torque/postgresql/coder.rb

@@ -3,8 +3,7 @@ module Torque
     module Coder
 
       # This class represents an Record to be encoded, instead of a literal Array
-      class Record < Array
-      end
+      Record = Class.new(Array)
 
       class << self
 

data/lib/torque/postgresql/config.rb

@@ -2,10 +2,6 @@ module Torque
   module PostgreSQL
     include ActiveSupport::Configurable
 
-    # 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
       ActiveRecord::Base.logger

data/lib/torque/postgresql/inheritance.rb

@@ -18,14 +18,7 @@ module Torque
         klass.find(self.id)
       end
 
-      private
-
-        def using_single_table_inheritance?(record) # :nodoc:
-          self.class.physically_inherited? || super
-        end
-
       module ClassMethods
-
         delegate :_auto_cast_attribute, :_record_class_attribute, to: ActiveRecord::Relation
 
         # Get a full list of all attributes from a model and all its dependents
@@ -101,9 +94,10 @@ module Torque
 
         # Get the final decorated table, regardless of any special condition
         def decorated_table_name
-          if parent < Base && !parent.abstract_class?
-            contained = parent.table_name
-            contained = contained.singularize if parent.pluralize_table_names
+          parent_class = try(:module_parent) || try(:parent)
+          if parent_class < Base && !parent_class.abstract_class?
+            contained = parent_class.table_name
+            contained = contained.singularize if parent_class.pluralize_table_names
             contained += "_"
           end
 
@@ -144,17 +138,19 @@ module Torque
 
         private
 
-          def discriminate_class_for_record(record) # :nodoc:
+          def instantiate_instance_of(klass, attributes, column_types = {}, &block)
+            return super unless klass.physically_inheritances?
+
             auto_cast = _auto_cast_attribute.to_s
             record_class = _record_class_attribute.to_s
+            return super unless attributes.key?(record_class) &&
+               attributes.delete(auto_cast) && attributes[record_class] != table_name
 
-            return super unless record.key?(record_class) &&
-              record.delete(auto_cast) && record[record_class] != table_name
+            klass = casted_dependents[attributes[record_class]]
+            raise_unable_to_cast(attributes[record_class]) if klass.nil?
+            filter_attributes_for_cast(attributes, klass)
 
-            klass = casted_dependents[record[record_class]]
-            raise_unable_to_cast(record[record_class]) if klass.nil?
-            filter_attributes_for_cast(record, klass)
-            klass
+            super(klass, attributes, column_types, &block)
           end
 
           # Filter the record attributes to be loaded to not included those from

data/lib/torque/postgresql/reflection/abstract_reflection.rb

@@ -12,28 +12,21 @@ module Torque
           false
         end
 
-        # Monkey patching for rais 5.0
-        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?
+        # Fix where the join_scope method is the one now responsible for
+        # building the join condition
+        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
+          scope_chain_items.inject(klass_scope, &:merge!)
         end
 
         # Manually build the join constraint
@@ -50,9 +43,9 @@ module Torque
           return klass_attr.eq(source_attr) unless connected_through_array?
 
           # Klass and key are associated with the reflection Class
-          klass_type = klass.columns_hash[torque_join_keys.key.to_s]
+          klass_type = klass.columns_hash[join_keys.key.to_s]
           # active_record and foreign_key are associated with the source Class
-          source_type = active_record.columns_hash[torque_join_keys.foreign_key.to_s]
+          source_type = active_record.columns_hash[join_keys.foreign_key.to_s]
 
           # If both are attributes but the left side is not an array, and the
           # right side is, use the ANY operation
@@ -78,8 +71,8 @@ module Torque
         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]
+            klass_attr  = table[join_keys.key.to_s]
+            source_attr = foreign_table[join_keys.foreign_key.to_s]
 
             build_id_constraint(klass_attr, source_attr)
           end
@@ -105,6 +98,7 @@ module Torque
           # returns either +nil+ or the inverse association name that it finds.
           def automatic_inverse_of
             return super unless connected_through_array?
+
             if can_find_inverse_of_automatically?(self)
               inverse_name = options[:as] || active_record.name.demodulize
               inverse_name = ActiveSupport::Inflector.underscore(inverse_name)

data/lib/torque/postgresql/relation.rb

@@ -52,11 +52,8 @@ module Torque
           when Array
             resolve_column(item, base)
           when Hash
-            raise ArgumentError, "Unsupported Hash for attributes on third level" if base
-            item.map do |key, other_list|
-              other_list = [other_list] unless other_list.kind_of? Enumerable
-              resolve_column(other_list, key)
-            end
+            raise ArgumentError, 'Unsupported Hash for attributes on third level' if base
+            item.map { |key, other_list| resolve_column(Array.wrap(other_list), key) }
           else
             raise ArgumentError, "Unsupported argument type: #{value} (#{value.class})"
           end
@@ -138,19 +135,17 @@ module Torque
     ActiveRecord::Relation::SINGLE_VALUE_METHODS       += Relation::SINGLE_VALUE_METHODS
     ActiveRecord::Relation::MULTI_VALUE_METHODS        += Relation::MULTI_VALUE_METHODS
     ActiveRecord::Relation::VALUE_METHODS              += Relation::VALUE_METHODS
-    ActiveRecord::QueryMethods::VALID_UNSCOPING_VALUES += [:cast_records, :itself_only,
-      :distinct_on, :auxiliary_statements]
+    ActiveRecord::QueryMethods::VALID_UNSCOPING_VALUES += %i[cast_records itself_only
+      distinct_on auxiliary_statements]
 
-    if ActiveRecord::QueryMethods.const_defined?('DEFAULT_VALUES')
-      Relation::SINGLE_VALUE_METHODS.each do |value|
-        ActiveRecord::QueryMethods::DEFAULT_VALUES[value] = nil \
-          if ActiveRecord::QueryMethods::DEFAULT_VALUES[value].nil?
-      end
+    Relation::SINGLE_VALUE_METHODS.each do |value|
+      ActiveRecord::QueryMethods::DEFAULT_VALUES[value] = nil \
+        if ActiveRecord::QueryMethods::DEFAULT_VALUES[value].nil?
+    end
 
-      Relation::MULTI_VALUE_METHODS.each do |value|
-        ActiveRecord::QueryMethods::DEFAULT_VALUES[value] ||= \
-          ActiveRecord::QueryMethods::FROZEN_EMPTY_ARRAY
-      end
+    Relation::MULTI_VALUE_METHODS.each do |value|
+      ActiveRecord::QueryMethods::DEFAULT_VALUES[value] ||= \
+        ActiveRecord::QueryMethods::FROZEN_EMPTY_ARRAY
     end
 
     $VERBOSE = warn_level

data/lib/torque/postgresql/relation/auxiliary_statement.rb

@@ -33,30 +33,24 @@ module Torque
         # Get all auxiliary statements bound attributes and the base bound
         # attributes as well
         def bound_attributes
-          if Torque::PostgreSQL::AR521
-            visitor = ::Arel::Visitors::PostgreSQL.new(ActiveRecord::Base.connection)
-            visitor.accept(self.arel.ast, ::Arel::Collectors::Bind.new).value
-          else
-            return super unless self.auxiliary_statements_values.present?
-            bindings = self.auxiliary_statements_values.map(&:bound_attributes)
-            (bindings + super).flatten
-          end
+          visitor = ::Arel::Visitors::PostgreSQL.new(ActiveRecord::Base.connection)
+          visitor.accept(self.arel.ast, ::Arel::Collectors::Bind.new).value
         end
 
         private
 
           # Hook arel build to add the distinct on clause
           def build_arel(*)
-            subqueries = build_auxiliary_statements
-            return super if subqueries.nil?
-            super.with(subqueries)
+            arel = super
+            subqueries = build_auxiliary_statements(arel)
+            subqueries.nil? ? arel : arel.with(subqueries)
           end
 
           # Build all necessary data for auxiliary statements
-          def build_auxiliary_statements
-            return unless self.auxiliary_statements_values.present?
-            self.auxiliary_statements_values.map do |klass|
-              klass.build(self)
+          def build_auxiliary_statements(arel)
+            return unless auxiliary_statements_values.present?
+            auxiliary_statements_values.map do |klass|
+              klass.build(self).tap { arel.join_sources.concat(klass.join_sources) }
             end
           end
 

data/lib/torque/postgresql/relation/distinct_on.rb

@@ -33,7 +33,7 @@ module Torque
 
           # Hook arel build to add the distinct on clause
           def build_arel(*)
-            arel = Torque::PostgreSQL::AR521 ? super : super()
+            arel = super
             value = self.distinct_on_values
             arel.distinct_on(resolve_column(value)) if value.present?
             arel

data/lib/torque/postgresql/schema_cache.rb

@@ -11,6 +11,7 @@ module Torque
         @data_sources_model_names = {}
         @inheritance_dependencies = {}
         @inheritance_associations = {}
+        @inheritance_loaded = false
       end
 
       def initialize_dup(*) # :nodoc:
@@ -22,16 +23,16 @@ module Torque
 
       def encode_with(coder) # :nodoc:
         super
-        coder["data_sources_model_names"] = @data_sources_model_names
-        coder["inheritance_dependencies"] = @inheritance_dependencies
-        coder["inheritance_associations"] = @inheritance_associations
+        coder['data_sources_model_names'] = @data_sources_model_names
+        coder['inheritance_dependencies'] = @inheritance_dependencies
+        coder['inheritance_associations'] = @inheritance_associations
       end
 
       def init_with(coder) # :nodoc:
         super
-        @data_sources_model_names = coder["data_sources_model_names"]
-        @inheritance_dependencies = coder["inheritance_dependencies"]
-        @inheritance_associations = coder["inheritance_associations"]
+        @data_sources_model_names = coder['data_sources_model_names']
+        @inheritance_dependencies = coder['inheritance_dependencies']
+        @inheritance_associations = coder['inheritance_associations']
       end
 
       def add(table_name, *) # :nodoc:
@@ -41,6 +42,7 @@ module Torque
         if @data_sources.key?(table_name)
           @inheritance_dependencies.clear
           @inheritance_associations.clear
+          @inheritance_loaded = false
         end
       end
 
@@ -49,6 +51,7 @@ module Torque
         @data_sources_model_names.clear
         @inheritance_dependencies.clear
         @inheritance_associations.clear
+        @inheritance_loaded = false
       end
 
       def size # :nodoc:
@@ -71,10 +74,12 @@ module Torque
           @inheritance_dependencies,
           @inheritance_associations,
           @data_sources_model_names,
+          @inheritance_loaded,
         ]
       end
 
       def marshal_load(array) # :nodoc:
+        @inheritance_loaded = array.pop
         @data_sources_model_names = array.pop
         @inheritance_associations = array.pop
         @inheritance_dependencies = array.pop
@@ -101,13 +106,13 @@ module Torque
       end
 
       # Try to find a model based on a given table
-      def lookup_model(table_name, scopred_class = '')
-        scopred_class = scopred_class.name if scopred_class.is_a?(Class)
+      def lookup_model(table_name, scoped_class = '')
+        scoped_class = scoped_class.name if scoped_class.is_a?(Class)
         return @data_sources_model_names[table_name] \
           if @data_sources_model_names.key?(table_name)
 
         # Get all the possible scopes
-        scopes = scopred_class.scan(/(?:::)?[A-Z][a-z]+/)
+        scopes = scoped_class.scan(/(?:::)?[A-Z][a-z]+/)
         scopes.unshift('Object::')
 
         # Consider the maximum namespaced possible model name
@@ -164,14 +169,17 @@ module Torque
         # Reload information about tables inheritance and dependencies, uses a
         # cache to not perform additional checkes
         def reload_inheritance_data!
-          return if @inheritance_dependencies.present?
+          return if @inheritance_loaded
           @inheritance_dependencies = connection.inherited_tables
           @inheritance_associations = generate_associations
+          @inheritance_loaded = true
         end
 
         # Calculates the inverted dependency (association), where even indirect
         # inheritance comes up in the list
         def generate_associations
+          return {} if @inheritance_dependencies.empty?
+
           result = Hash.new{ |h, k| h[k] = [] }
           masters = @inheritance_dependencies.values.flatten.uniq
 
@@ -200,7 +208,7 @@ module Torque
           super
           @data_sources_model_names = Torque::PostgreSQL.config
             .irregular_models.slice(*@data_sources.keys).map do |table_name, model_name|
-            [table_name, model_name.constantize]
+            [table_name, (model_name.is_a?(Class) ? model_name : model_name.constantize)]
           end.to_h
         end