torque-postgresql 1.1.8 → 2.0.0

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

@@ -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,11 +29,10 @@ 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
 
-              records.default_proc = nil
               owners.each do |owner|
                 associate_records_to_owner(owner, records[owner[owner_key_name]] || [])
               end
@@ -48,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/autosave_association.rb

@@ -25,11 +25,11 @@ module Torque
         association = association_instance_get(reflection.name)
         return unless association
 
-        klass_attr = reflection.active_record_primary_key
-        source_attr = reflection.foreign_key
+        klass_fk = reflection.foreign_key
+        acpk = reflection.active_record_primary_key
 
-        records = association.target.each_with_object(klass_attr)
-        write_attribute(source_attr, records.map(&:read_attribute).compact)
+        records = association.target.each_with_object(klass_fk)
+        write_attribute(acpk, records.map(&:read_attribute).compact)
       end
     end
 

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,12 +2,6 @@ module Torque
   module PostgreSQL
     include ActiveSupport::Configurable
 
-    # Stores a version check for compatibility purposes
-    AR510 = (ActiveRecord.gem_version >= Gem::Version.new('5.1.0'))
-    AR520 = (ActiveRecord.gem_version >= Gem::Version.new('5.2.0'))
-    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/reflection/belongs_to_many_reflection.rb

@@ -10,10 +10,6 @@ module Torque
           true
         end
 
-        def belongs_to?
-          true
-        end
-
         def collection?
           true
         end
@@ -23,7 +19,7 @@ module Torque
         end
 
         def foreign_key
-          @foreign_key ||= options[:foreign_key] || derive_foreign_key.freeze
+          @foreign_key ||= options[:primary_key] || derive_foreign_key.freeze
         end
 
         def association_foreign_key
@@ -31,46 +27,16 @@ module Torque
         end
 
         def active_record_primary_key
-          @active_record_primary_key ||= options[:primary_key] || derive_primary_key
-        end
-
-        unless PostgreSQL::AR510
-          def join_keys(*)
-            JoinKeys.new(join_pk, join_fk)
-          end
-        end
-
-        if PostgreSQL::AR520
-          def join_primary_key(*)
-            active_record_primary_key
-          end
-
-          def join_foreign_key
-            foreign_key
-          end
-        else
-          def join_id_for(owner)
-            owner[foreign_key]
-          end
+          @active_record_primary_key ||= options[:foreign_key] || derive_primary_key
         end
 
         private
 
-          unless PostgreSQL::AR520
-            def join_pk(*)
-              active_record_primary_key
-            end
-
-            def join_fk
-              foreign_key
-            end
-          end
-
-          def derive_primary_key
+          def derive_foreign_key
             klass.primary_key
           end
 
-          def derive_foreign_key
+          def derive_primary_key
             "#{name.to_s.singularize}_ids"
           end
       end

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.8'
+    VERSION = '2.0.0'
   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'