torque-postgresql 1.1.4 → 2.0.2

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

@@ -211,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)

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,14 +33,8 @@ 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

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/version.rb

@@ -1,5 +1,5 @@
 module Torque
   module PostgreSQL
-    VERSION = '1.1.4'
+    VERSION = '2.0.2'
   end
 end

data/spec/en.yml

@@ -0,0 +1,19 @@
+en:
+  torque: 'Torque Rocks!'
+  activerecord:
+    attributes:
+      user:
+        role:
+          visitor: 'A simple Visitor'
+      role:
+        assistant: 'An Assistant'
+    enums:
+      content_status:
+        created: '1 - Created'
+      roles:
+        manager: 'The Manager'
+  enum:
+    content_status:
+      draft: 'Draft (2)'
+    published: 'Finally published'
+    admin: 'Super Duper Admin'

data/spec/factories/authors.rb

@@ -0,0 +1,6 @@
+FactoryBot.define do
+  factory :author do
+    name      { Faker::Name.name }
+    specialty { Enum::Specialties.values.sample }
+  end
+end

data/spec/factories/comments.rb

@@ -0,0 +1,13 @@
+FactoryBot.define do
+  factory :comment do
+    content { Faker::Lorem.paragraph }
+
+    factory :comment_recursive do
+      comment_id { Comment.order('RANDOM()').first.id }
+    end
+
+    trait :random_user do
+      user_id { User.order('RANDOM()').first.id }
+    end
+  end
+end

data/spec/factories/posts.rb

@@ -0,0 +1,6 @@
+FactoryBot.define do
+  factory :post do
+    title   { Faker::Lorem.sentence }
+    content { Faker::Lorem.paragraph }
+  end
+end

data/spec/factories/tags.rb

@@ -0,0 +1,5 @@
+FactoryBot.define do
+  factory :tag do
+    name { Faker::Lorem.sentence }
+  end
+end

data/spec/factories/texts.rb

@@ -0,0 +1,5 @@
+FactoryBot.define do
+  factory :text do
+    content { Faker::Lorem.sentence }
+  end
+end

data/spec/factories/users.rb

@@ -0,0 +1,6 @@
+FactoryBot.define do
+  factory :user do
+    name { Faker::Name.name }
+    role { 'visitor' }
+  end
+end

data/spec/factories/videos.rb

@@ -0,0 +1,5 @@
+FactoryBot.define do
+  factory :video do
+    title { Faker::Lorem.sentence }
+  end
+end

data/spec/mocks/cache_query.rb

@@ -0,0 +1,16 @@
+module Mocks
+  module CacheQuery
+    def get_last_executed_query(&block)
+      conn = ActiveRecord::Base.connection
+      conn.instance_variable_set(:@query_cache_enabled, true)
+
+      block.call
+      result = conn.query_cache.keys.first
+
+      conn.instance_variable_set(:@query_cache_enabled, false)
+      conn.instance_variable_get(:@query_cache).delete(result)
+
+      result
+    end
+  end
+end

data/spec/mocks/create_table.rb

@@ -0,0 +1,35 @@
+module Mocks
+  module CreateTable
+    def mock_create_table
+      path = ActiveRecord::Base.connection.method(:create_table).super_method.source_location[0]
+
+      before :all do
+        ActiveRecord::ConnectionAdapters::SchemaStatements.send(:define_method, :create_table) do |table_name, **options, &block|
+          td = create_table_definition(table_name, **options)
+
+          # Does things as the same as schema statements
+          if options[:id] != false && !options[:as]
+            pk = options.fetch(:primary_key) do
+              ActiveRecord::Base.get_primary_key table_name.to_s.singularize
+            end
+
+            if pk.is_a?(Array)
+              td.primary_keys pk
+            else
+              td.primary_key pk, options.fetch(:id, :primary_key), **options
+            end
+          end
+
+          block.call(td) if block.present?
+
+          # Now generate the SQL and return it
+          schema_creation.accept td
+        end
+      end
+
+      after :all do
+        load path
+      end
+    end
+  end
+end

data/spec/models/activity.rb

@@ -0,0 +1,3 @@
+class Activity < ActiveRecord::Base
+  belongs_to :author
+end

data/spec/models/activity_book.rb

@@ -0,0 +1,4 @@
+require_relative 'activity'
+
+class ActivityBook < Activity
+end