torque-postgresql 2.2.4 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95fa82a4869d180b12518b184191e6877b9e6cf3108fb5e68e55d6a836809389
-  data.tar.gz: 45c6e24a30b3782ec26ff5caafe01430c24f137c460eb19b6f2a49e0b6609142
+  metadata.gz: d4fac19ef8680f477df0f79502331ddda06266658a54c8128321d68145a9f18b
+  data.tar.gz: 0e93ec49f80d40ec9ce9b7fcc5ef0eff65a882cad79a63e5429657ad9c66691b
 SHA512:
-  metadata.gz: cd7e925ab13b8ae3eb6f0d92fbb994f12c6c121998792263b0752eb9647c0d2e4f72dec8d3973c6e0365fe0c5194a2af5fba9189189743c5bca7b06a4e6dfa41
-  data.tar.gz: 470bb4e8b0816318ca5ee1b99e1896a8a4f3297af46e653de4ddac5347cf40a781b530a4e2531cf41eae38f7205332e52ced09e5b857a618f965851a6d9d7162
+  metadata.gz: 4a9abd492b544296c29e0949e1ad0ad4852a1ed0c48379551e5ffbbaad7018579cad994ac2a841231603bdddd8da4b448d7771a9086312289f818124d842d6a6
+  data.tar.gz: 8019255d20eff471ed177078e1bd6042a0a9b95752d32578bdb8ce86afdf9cffbefa8ed181caab0143f0dbbf80cfc39c99fd005cfc2b28089687b26a635268ef

data/lib/torque/postgresql/adapter/database_statements.rb

@@ -34,6 +34,15 @@ module Torque
           execute("SET SESSION IntervalStyle TO 'iso_8601'", 'SCHEMA')
         end
 
+        # Since enums create new types, type map needs to be rebooted to include
+        # the new ones, both normal and array one
+        def create_enum(name, *)
+          super
+
+          oid = query_value("SELECT #{quote(name)}::regtype::oid", "SCHEMA").to_i
+          load_additional_types([oid])
+        end
+
         # Change some of the types being mapped
         def initialize_type_map(m = type_map)
           super
@@ -54,7 +63,7 @@ module Torque
 
         # Add the composite types to be loaded too.
         def torque_load_additional_types(oids = nil)
-          filter = "AND     a.typelem::integer IN (%s)" % oids.join(", ") if oids
+          filter = ("AND     a.typelem::integer IN (%s)" % oids.join(', ')) if oids
 
           query = <<-SQL
             SELECT      a.typelem AS oid, t.typname, t.typelem,
@@ -132,7 +141,9 @@ module Torque
         # Get the list of columns, and their definition, but only from the
         # actual table, does not include columns that comes from inherited table
         def column_definitions(table_name) # :nodoc:
+          # Only affects inheritance
           local_condition = 'AND a.attislocal IS TRUE' if @_dump_mode
+
           query(<<-SQL, 'SCHEMA')
               SELECT a.attname, format_type(a.atttypid, a.atttypmod),
                      pg_get_expr(d.adbin, d.adrelid), a.attnotnull, a.atttypid, a.atttypmod,

data/lib/torque/postgresql/adapter/oid/enum_set.rb

@@ -14,7 +14,7 @@ module Torque
           end
 
           def type
-            :enum_set
+            :enum
           end
 
           def deserialize(value)

data/lib/torque/postgresql/adapter/oid.rb

@@ -19,9 +19,6 @@ module Torque
       ActiveRecord::Type.register(:enum_set, OID::EnumSet,  adapter: :postgresql)
       ActiveRecord::Type.register(:line,     OID::Line,     adapter: :postgresql)
       ActiveRecord::Type.register(:segment,  OID::Segment,  adapter: :postgresql)
-
-      ActiveRecord::Type.register(:interval, OID::Interval, adapter: :postgresql) \
-        unless PostgreSQL::AR610
     end
   end
 end

data/lib/torque/postgresql/adapter/quoting.rb

@@ -22,27 +22,19 @@ module Torque
         end
 
         def quote_default_expression(value, column)
-          return super unless value.class <= Array &&
-            ((column.is_a?(ColumnDefinition) && column.dig(:options, :array)) ||
-            (column.is_a?(Column) && column.array?))
-
-          type = column.is_a?(Column) ? column.sql_type_metadata.sql_type : column.sql_type
-          quote(value) + '::' + type
+          return super unless value.class <= Array || value.class <= Set
+
+          type =
+            if column.is_a?(ColumnDefinition) && column.options.try(:[], :array)
+              # This is the general way
+              lookup_cast_type(column.sql_type)
+            elsif column.is_a?(Column) && column.array?
+              # When using +change_column_default+
+              lookup_cast_type_from_column(column)
+            end
+
+          type.nil? ? super : quote(type.serialize(value.to_a))
         end
-
-        private
-
-          def _quote(value)
-            return super unless value.is_a?(Array)
-
-            values = value.map(&method(:quote))
-            "ARRAY[#{values.join(','.freeze)}]"
-          end
-
-          def _type_cast(value)
-            return super unless value.is_a?(Array)
-            value.map(&method(:quote)).join(','.freeze)
-          end
       end
     end
   end

data/lib/torque/postgresql/adapter/schema_creation.rb

@@ -33,8 +33,7 @@ module Torque
           create_sql << "(#{statements.join(', ')})" \
             if statements.present? || o.inherits.present?
 
-          options = PostgreSQL::AR610 ? o : table_options(o)
-          add_table_options!(create_sql, options)
+          add_table_options!(create_sql, o)
 
           if o.inherits.present?
             tables = o.inherits.map(&method(:quote_table_name))

data/lib/torque/postgresql/adapter/schema_definitions.rb

@@ -3,35 +3,7 @@
 module Torque
   module PostgreSQL
     module Adapter
-      module ColumnMethods
-
-        # Creates a column with an interval type, allowing span of times and
-        # dates to be stored without having to store a seconds-based integer
-        # or any sort of other approach
-        def interval(*args, **options)
-          args.each { |name| column(name, :interval, **options) }
-        end
-
-        # Creates a column with an enum type, needing to specify the enum_type,
-        # which is basically the name of the type defined prior creating the
-        # column
-        def enum(*args, **options)
-          enum_type = [options.delete(:subtype), options.delete(:enum_type)].compact.first
-          args.each { |name| column(name, (enum_type || name), **options) }
-        end
-
-        # Creates a column with an enum array type, needing to specify the
-        # enum_type, which is basically the name of the type defined prior
-        # creating the column
-        def enum_set(*args, **options)
-          super(*args, **options.merge(array: true))
-        end
-
-      end
-
       module TableDefinition
-        include ColumnMethods
-
         attr_reader :inherits
 
         def initialize(*args, **options)
@@ -42,16 +14,7 @@ module Torque
         end
       end
 
-      ActiveRecord::ConnectionAdapters::PostgreSQL::Table.include ColumnMethods
       ActiveRecord::ConnectionAdapters::PostgreSQL::TableDefinition.include TableDefinition
-
-      if ActiveRecord::ConnectionAdapters::PostgreSQL.const_defined?('ColumnDefinition')
-        module ColumnDefinition
-          attr_accessor :subtype, :enum_type
-        end
-
-        ActiveRecord::ConnectionAdapters::PostgreSQL::ColumnDefinition.include ColumnDefinition
-      end
     end
   end
 end

data/lib/torque/postgresql/adapter/schema_dumper.rb

@@ -12,33 +12,13 @@ module Torque
           stream
         end
 
-        def extensions(stream) # :nodoc:
-          super
-          user_defined_types(stream)
-        end
-
         # Translate +:enum_set+ into +:enum+
         def schema_type(column)
           column.type == :enum_set ? :enum : super
         end
 
-        # Adds +:enum_type+ option to the default set
-        def prepare_column_options(column)
-          spec = super
-
-          if enum_type = schema_enum_type(column)
-            spec[:enum_type] = enum_type
-          end
-
-          spec
-        end
-
         private
 
-          def schema_enum_type(column)
-            column.sql_type.to_sym.inspect if column.type == :enum || column.type == :enum_set
-          end
-
           def tables(stream) # :nodoc:
             inherited_tables = @connection.inherited_tables
             sorted_tables = @connection.tables.sort - @connection.views
@@ -83,27 +63,6 @@ module Torque
             functions(stream) if defined?(::Fx::SchemaDumper::Function)
             triggers(stream) if defined?(::Fx::SchemaDumper::Trigger)
           end
-
-          # Dump user defined types like enum
-          def user_defined_types(stream)
-            types = @connection.user_defined_types('e')
-            return unless types.any?
-
-            stream.puts "  # Custom types defined in this database."
-            stream.puts "  # Note that some types may not work with other database engines. Be careful if changing database."
-            types.sort_by(&:first).each { |(name, type)| send(type.to_sym, name, stream) }
-            stream.puts
-          rescue => e
-            stream.puts "# Could not dump user-defined types because of following #{e.class}"
-            stream.puts "#   #{e.message}"
-            stream.puts
-          end
-
-          # Dump enum custom type
-          def enum(name, stream)
-            values = @connection.enum_values(name).map { |v| "\"#{v}\"" }
-            stream.puts "  create_enum \"#{name}\", [#{values.join(', ')}], force: :cascade"
-          end
       end
 
       ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaDumper.prepend SchemaDumper

data/lib/torque/postgresql/adapter/schema_statements.rb

@@ -25,21 +25,6 @@ module Torque
           SQL
         end
 
-        # Creates a new PostgreSQL enumerator type
-        #
-        # Example:
-        #   create_enum 'status', ['foo', 'bar']
-        #   create_enum 'status', ['foo', 'bar'], prefix: true
-        #   create_enum 'status', ['foo', 'bar'], suffix: 'test'
-        #   create_enum 'status', ['foo', 'bar'], force: true
-        def create_enum(name, values, options = {})
-          drop_type(name, options) if options[:force]
-          execute <<-SQL.squish
-            CREATE TYPE #{quote_type_name(name, options[:schema])} AS ENUM
-            (#{quote_enum_values(name, values, options).join(', ')})
-          SQL
-        end
-
         # Changes the enumerator by adding new values
         #
         # Example:

data/lib/torque/postgresql/adapter.rb

@@ -49,15 +49,6 @@ module Torque
           end
         end
       end
-
-      # Extend the extract default value to support array
-      def extract_value_from_default(default)
-        return super unless Torque::PostgreSQL.config.use_extended_defaults
-        return super unless default&.match(/ARRAY\[(.*?)\](?:::"?([\w. ]+)"?(?:\[\])+)?$/)
-
-        arr = $1.split(/(?!\B\[[^\]]*), ?(?![^\[]*\]\B)/)
-        DeduplicatableArray.new(arr.map(&method(:extract_value_from_default)))
-      end
     end
 
     ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.prepend Adapter

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

@@ -53,8 +53,8 @@ module Torque
 
         def load_target
           if stale_target? || find_target?
-            new_records = PostgreSQL::AR615 ? target.extract!(&:persisted?) : []
-            @target = merge_target_lists((find_target || []) + new_records, target)
+            persisted_records = (find_target || []) + target.extract!(&:persisted?)
+            @target = merge_target_lists(persisted_records, target)
           end
 
           loaded!
@@ -228,8 +228,9 @@ module Torque
           end
 
           def invertible_for?(record)
-            inverse = inverse_reflection_for(record)
-            inverse && (inverse.has_many? && inverse.connected_through_array?)
+            return unless (inverse = inverse_reflection_for(record))
+            collection_class = ::ActiveRecord::Associations::HasManyAssociation
+            inverse.is_a?(collection_class) && inverse.connected_through_array?
           end
 
           def stale_state

data/lib/torque/postgresql/associations/{association.rb → foreign_association.rb}

@@ -3,7 +3,7 @@
 module Torque
   module PostgreSQL
     module Associations
-      module Association
+      module ForeignAssociation
 
         # There is no problem of adding temporary items on target because
         # CollectionProxy will handle memory and persisted relationship
@@ -33,9 +33,6 @@ module Torque
           end
 
       end
-
-      ::ActiveRecord::Associations::Association.prepend(Association)
-      ::ActiveRecord::Associations::HasManyAssociation.prepend(Association)
     end
   end
 end

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

@@ -11,8 +11,61 @@ 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
+            return self if run?
             return super unless connected_through_array?
+
+            @run = true
             send("run_array_for_#{@reflection.macro}")
+            self
+          end
+
+          # Correctly correlate records when they are connected theough an array
+          def set_inverse(record)
+            return super unless connected_through_array? && @reflection.macro == :has_many
+
+            # Only the first owner is associated following the same instruction
+            # on the original implementation
+            convert_key(record[association_key_name])&.each do |key|
+              if owners = owners_by_key[key]
+                association = owners.first.association(reflection.name)
+                association.set_inverse_instance(record)
+              end
+            end
+          end
+
+          # Requires a slight change when running on has many since the value
+          # of the foreign key being an array
+          def load_records(raw_records = nil)
+            return super unless connected_through_array? && @reflection.macro == :has_many
+
+            @records_by_owner = {}.compare_by_identity
+            raw_records ||= loader_query.records_for([self])
+
+            @preloaded_records = raw_records.select do |record|
+              assignments = false
+
+              keys = convert_key(record[association_key_name]) || []
+              owners_by_key.values_at(*keys).each do |owner|
+                entries = (@records_by_owner[owner] ||= [])
+
+                if reflection.collection? || entries.empty?
+                  entries << record
+                  assignments = true
+                end
+              end
+
+              assignments
+            end
+          end
+
+          # Make sure to change the process when connected through an array
+          def owners_by_key
+            return super unless connected_through_array?
+            @owners_by_key ||= owners.each_with_object({}) do |owner, result|
+              Array.wrap(convert_key(owner[owner_key_name])).each do |key|
+                (result[key] ||= []) << owner
+              end
+            end
           end
 
           private
@@ -41,32 +94,6 @@ module Torque
               end
             end
 
-            if PostgreSQL::AR604
-            # This is how Rails 6.0.4 and 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)

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module Associations
+      module Preloader
+        module LoaderQuery
+          def foreign_column
+            @foreign_column ||= scope.columns_hash[association_key_name]
+          end
+
+          def load_records_for_keys(keys, &block)
+            condition = query_condition_for(keys)
+            scope.where(condition).load(&block)
+          end
+
+          def query_condition_for(keys)
+            if connected_through_array?
+              value = scope.cast_for_condition(foreign_column, keys.to_a)
+              scope.table[association_key_name].overlaps(value)
+            else
+              { association_key_name => keys }
+            end
+          end
+
+          def connected_through_array?
+            foreign_column.array?
+          end
+        end
+
+        ::ActiveRecord::Associations::Preloader::Association::LoaderQuery
+          .prepend(LoaderQuery)
+      end
+    end
+  end
+end

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

@@ -1 +1,2 @@
 require_relative 'preloader/association'
+require_relative 'preloader/loader_query'

data/lib/torque/postgresql/associations.rb

@@ -1,5 +1,10 @@
-require_relative 'associations/association'
 require_relative 'associations/association_scope'
 require_relative 'associations/belongs_to_many_association'
+require_relative 'associations/foreign_association'
+
 require_relative 'associations/builder'
 require_relative 'associations/preloader'
+
+association_mod = Torque::PostgreSQL::Associations::ForeignAssociation
+::ActiveRecord::Associations::HasManyAssociation.prepend(association_mod)
+::ActiveRecord::Associations::BelongsToManyAssociation.prepend(association_mod)

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

@@ -220,7 +220,7 @@ module Torque
               @arel_threshold_value ||= begin
                 case threshold
                 when Symbol, String
-                  "arel_attribute('#{threshold}')"
+                  "arel_table['#{threshold}']"
                 when ActiveSupport::Duration
                   value = "'#{threshold.to_i} seconds'"
                   "::Arel.sql(\"#{value}\").cast(:interval)"
@@ -453,7 +453,11 @@ module Torque
               attr_value = threshold.present? ? method_names[:real] : attribute
               default_value = default.inspect
 
-              "#{attr_value}.nil? ? #{default_value} : #{attr_value}.include?(value)"
+              [
+                "return #{default_value} if #{attr_value}.nil?",
+                "(#{attr_value}.min.try(:infinite?) || #{attr_value}.min <= value) &&",
+                "  (#{attr_value}.max.try(:infinite?) || #{attr_value}.max > value)",
+              ].join("\n")
             end
 
             def instance_start

data/lib/torque/postgresql/config.rb

@@ -4,11 +4,6 @@ module Torque
   module PostgreSQL
     include ActiveSupport::Configurable
 
-    # Stores a version check for compatibility purposes
-    AR604 = (ActiveRecord.gem_version >= Gem::Version.new('6.0.4'))
-    AR610 = (ActiveRecord.gem_version >= Gem::Version.new('6.1.0'))
-    AR615 = (ActiveRecord.gem_version >= Gem::Version.new('6.1.5'))
-
     # Use the same logger as the Active Record one
     def self.logger
       ActiveRecord::Base.logger
@@ -27,11 +22,6 @@ module Torque
     # same configuration is set to true
     config.eager_load = false
 
-    # This allows default values to have extended values like arrays and casted
-    # values. Extended defaults are still experimental, so enable and test it
-    # before using it in prod
-    config.use_extended_defaults = false
-
     # Set a list of irregular model name when associated with table names
     config.irregular_models = {}
     def config.irregular_models=(hash)
@@ -67,11 +57,11 @@ module Torque
 
       # The name of the method to be used on any ActiveRecord::Base to
       # initialize model-based enum features
-      enum.base_method = :enum
+      enum.base_method = :torque_enum
 
       # The name of the method to be used on any ActiveRecord::Base to
       # initialize model-based enum set features
-      enum.set_method = :enum_set
+      enum.set_method = :torque_enum_set
 
       # Indicates if bang methods like 'disabled!' should update the record on
       # database or not

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

@@ -6,6 +6,9 @@ module Torque
       module AbstractReflection
         AREL_ATTR = ::Arel::Attributes::Attribute
 
+        ARR_NO_CAST = 'bigint'
+        ARR_CAST = 'bigint[]'
+
         # Check if the foreign key actually exists
         def connected_through_array?
           false
@@ -37,36 +40,39 @@ module Torque
           result
         end
 
-        # Build the id constraint checking if both types are perfect matching.
-        # The klass attribute (left side) will always be a column attribute
+        # Build the id constraint checking if both types are perfect matching
         def build_id_constraint(klass_attr, source_attr)
           return klass_attr.eq(source_attr) unless connected_through_array?
 
           # Klass and key are associated with the reflection Class
-          klass_type = klass.columns_hash[join_keys.key.to_s]
-
-          # Apply an ANY operation which checks if the single value on the left
-          # side exists in the array on the right side
-          if source_attr.is_a?(AREL_ATTR)
-            any_value = [klass_attr, source_attr]
-            any_value.reverse! if klass_type.try(:array?)
-            return any_value.shift.eq(::Arel::Nodes::NamedFunction.new('ANY', any_value))
-          end
+          klass_type = klass.columns_hash[join_primary_key.to_s]
+          # active_record and foreign_key are associated with the source Class
+          source_type = active_record.columns_hash[join_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
+          any_operation = arel_array_to_any(klass_attr, source_attr, klass_type, source_type)
+          return klass_attr.eq(any_operation) if any_operation
 
           # If the left side is not an array, just use the IN condition
           return klass_attr.in(source_attr) unless klass_type.try(:array)
 
-          # Build the overlap condition (array && array) ensuring that the right
-          # side has the same type as the left side
-          source_attr = ::Arel::Nodes.build_quoted(Array.wrap(source_attr))
-          klass_attr.overlaps(source_attr.cast(klass_type.sql_type_metadata.sql_type))
+          # Decide if should apply a cast to ensure same type comparision
+          should_cast = klass_type.type.eql?(:integer) && source_type.type.eql?(:integer)
+          should_cast &= !klass_type.sql_type.eql?(source_type.sql_type)
+          should_cast |= !(klass_attr.is_a?(AREL_ATTR) && source_attr.is_a?(AREL_ATTR))
+
+          # Apply necessary transformations to values
+          klass_attr = cast_constraint_to_array(klass_type, klass_attr, should_cast)
+          source_attr = cast_constraint_to_array(source_type, source_attr, should_cast)
+
+          # Return the overlap condition
+          klass_attr.overlaps(source_attr)
         end
 
-        if PostgreSQL::AR610
-          # TODO: Deprecate this method
-          def join_keys
-            OpenStruct.new(key: join_primary_key, foreign_key: join_foreign_key)
-          end
+        # TODO: Deprecate this method
+        def join_keys
+          OpenStruct.new(key: join_primary_key, foreign_key: join_foreign_key)
         end
 
         private
@@ -77,6 +83,24 @@ module Torque
 
             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)
+            return value if base_ready && (type.sql_type.eql?(ARR_NO_CAST) || !should_cast)
+
+            value = ::Arel::Nodes.build_quoted(Array.wrap(value)) unless base_ready
+            value = value.cast(ARR_CAST) if should_cast
+            value
+          end
+
+          # Check if it's possible to turn both attributes into an ANY condition
+          def arel_array_to_any(klass_attr, source_attr, klass_type, source_type)
+            return unless !klass_type.try(:array) && source_type.try(:array) &&
+              klass_attr.is_a?(AREL_ATTR) && source_attr.is_a?(AREL_ATTR)
+
+            ::Arel::Nodes::NamedFunction.new('ANY', [source_attr])
+          end
       end
 
       ::ActiveRecord::Reflection::AbstractReflection.prepend(AbstractReflection)

data/lib/torque/postgresql/relation.rb

@@ -19,6 +19,8 @@ module Torque
       MULTI_VALUE_METHODS = [:distinct_on, :auxiliary_statements, :cast_records, :select_extra]
       VALUE_METHODS = SINGLE_VALUE_METHODS + MULTI_VALUE_METHODS
 
+      ARColumn = ::ActiveRecord::ConnectionAdapters::PostgreSQL::Column
+
       # :nodoc:
       def select_extra_values; get_value(:select_extra); end
       # :nodoc:
@@ -74,6 +76,14 @@ module Torque
         end
       end
 
+      # Serialize the given value so it can be used in a condition tha involves
+      # the given column
+      def cast_for_condition(column, value)
+        column = columns_hash[column.to_s] unless column.is_a?(ARColumn)
+        caster = connection.lookup_cast_type_from_column(column)
+        connection.type_cast(caster.serialize(value))
+      end
+
       private
 
         def build_arel(*)
@@ -140,18 +150,6 @@ module Torque
     ActiveRecord::QueryMethods::VALID_UNSCOPING_VALUES += %i[cast_records itself_only
       distinct_on auxiliary_statements]
 
-    unless AR610
-      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
-    end
-
     $VERBOSE = warn_level
   end
 end

data/lib/torque/postgresql/schema_cache.rb

@@ -109,6 +109,7 @@ module Torque
 
       # Try to find a model based on a given table
       def lookup_model(table_name, scoped_class = '')
+        # byebug if table_name == 'activities'
         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)
@@ -123,7 +124,7 @@ module Torque
 
         # Test all the possible names against all the possible scopes
         until scopes.size == 0
-          scope = scopes.join.safe_constantize
+          scope = scopes.join.chomp('::').safe_constantize
           model = find_model(max_name, table_name, scope) unless scope.nil?
           return @data_sources_model_names[table_name] = model unless model.nil?
           scopes.pop

data/lib/torque/postgresql/version.rb

@@ -2,6 +2,6 @@
 
 module Torque
   module PostgreSQL
-    VERSION = '2.2.4'
+    VERSION = '3.0.0'
   end
 end

data/lib/torque-postgresql.rb

@@ -1,2 +1 @@
 require 'torque/postgresql'
-require 'torque/range'

data/spec/schema.rb

@@ -22,11 +22,11 @@ ActiveRecord::Schema.define(version: version) do
 
   # Custom types defined in this database.
   # Note that some types may not work with other database engines. Be careful if changing database.
-  create_enum "content_status", ["created", "draft", "published", "archived"], force: :cascade
-  create_enum "specialties", ["books", "movies", "plays"], force: :cascade
-  create_enum "roles", ["visitor", "assistant", "manager", "admin"], force: :cascade
-  create_enum "conflicts", ["valid", "invalid", "untrusted"], force: :cascade
-  create_enum "types", ["A", "B", "C", "D"], force: :cascade
+  create_enum "content_status", ["created", "draft", "published", "archived"]
+  create_enum "specialties", ["books", "movies", "plays"]
+  create_enum "roles", ["visitor", "assistant", "manager", "admin"]
+  create_enum "conflicts", ["valid", "invalid", "untrusted"]
+  create_enum "types", ["A", "B", "C", "D"]
 
   create_table "geometries", force: :cascade do |t|
     t.point   "point"

data/spec/spec_helper.rb

@@ -39,7 +39,6 @@ RSpec.configure do |config|
 
   # Handles acton before rspec initialize
   config.before(:suite) do
-    ActiveSupport::Deprecation.silenced = true
     DatabaseCleaner.clean_with(:truncation)
   end
 

data/spec/tests/arel_spec.rb

@@ -51,8 +51,6 @@ RSpec.describe 'Arel' do
   context 'on default value' do
     let(:connection) { ActiveRecord::Base.connection }
 
-    before(:context) { Torque::PostgreSQL.config.use_extended_defaults = true }
-    after(:context) { Torque::PostgreSQL.config.use_extended_defaults = false }
     after { Author.reset_column_information }
 
     it 'does not break the change column default value method' do
@@ -76,7 +74,7 @@ RSpec.describe 'Arel' do
 
       expect do
         connection.create_enum(:samples, %i[a b c d])
-        connection.add_column(:authors, :samples, :samples, array: true, default: value)
+        connection.add_column(:authors, :samples, :enum, enum_type: :samples, array: true, default: value)
       end.not_to raise_error
 
       expect(Author.new.samples).to eq(value)
@@ -84,7 +82,7 @@ RSpec.describe 'Arel' do
 
     it 'works with an array with enum values for an existing enum' do
       value = ['visitor', 'assistant']
-      expect { connection.add_column(:authors, :roles, :roles, array: true, default: value) }.not_to raise_error
+      expect { connection.add_column(:authors, :roles, :enum, enum_type: :roles, array: true, default: value) }.not_to raise_error
       expect(Author.new.roles).to eq(value)
     end
 

data/spec/tests/belongs_to_many_spec.rb

@@ -344,7 +344,8 @@ RSpec.describe 'BelongsToMany' do
       subject.tags.concat(records)
 
       entries = Video.all
-      ActiveRecord::Associations::Preloader.new.preload(entries, :tags, Tag.all)
+      arguments = { records: entries, associations: :tags, available_records: Tag.all.to_a }
+      ActiveRecord::Associations::Preloader.new(**arguments).call
       entries = entries.load
 
       expect(entries.size).to be_eql(1)
@@ -392,53 +393,4 @@ RSpec.describe 'BelongsToMany' do
       end
     end
   end
-
-  context 'using uuid' do
-    let(:connection) { ActiveRecord::Base.connection }
-    let(:game) { Class.new(ActiveRecord::Base) }
-    let(:player) { Class.new(ActiveRecord::Base) }
-    let(:other) { player.create }
-
-    # TODO: Set as a shred example
-    before do
-      connection.create_table(:players, id: :uuid) { |t| t.string :name }
-      connection.create_table(:games, id: :uuid) { |t| t.uuid :player_ids, array: true }
-
-      options = { anonymous_class: player, foreign_key: :player_ids }
-      options[:inverse_of] = false if Torque::PostgreSQL::AR610
-
-      game.table_name = 'games'
-      player.table_name = 'players'
-      game.belongs_to_many :players, **options
-    end
-
-    subject { game.create }
-
-    it 'loads associated records' do
-      subject.update(player_ids: [other.id])
-      expect(subject.players.to_sql).to be_eql(<<-SQL.squish)
-        SELECT "players".* FROM "players" WHERE "players"."id" IN ('#{other.id}')
-      SQL
-
-      expect(subject.players.load).to be_a(ActiveRecord::Associations::CollectionProxy)
-      expect(subject.players.to_a).to be_eql([other])
-    end
-
-    it 'can preload records' do
-      records = 5.times.map { player.create }
-      subject.players.concat(records)
-
-      entries = game.all.includes(:players).load
-
-      expect(entries.size).to be_eql(1)
-      expect(entries.first.players).to be_loaded
-      expect(entries.first.players.size).to be_eql(5)
-    end
-
-    it 'can joins records' do
-      query = game.all.joins(:players)
-      expect(query.to_sql).to match(/INNER JOIN "players"/)
-      expect { query.load }.not_to raise_error
-    end
-  end
 end

data/spec/tests/enum_set_spec.rb

@@ -31,7 +31,8 @@ RSpec.describe 'Enum' do
     it 'can be defined as an array' do
       subject.enum(:content_status, array: true, enum_type: :content_status)
       expect(subject['content_status'].name).to be_eql('content_status')
-      expect(subject['content_status'].type).to be_eql(:content_status)
+      expect(subject['content_status'].type).to be_eql(:enum)
+      expect(subject['content_status'].options[:enum_type]).to be_eql(:content_status)
 
       array = subject['content_status'].respond_to?(:options) \
         ? subject['content_status'].options[:array] \
@@ -44,14 +45,14 @@ RSpec.describe 'Enum' do
   context 'on schema' do
     it 'can be used on tables' do
       dump_io = StringIO.new
-      checker = /t\.enum +"conflicts", +array: true, +enum_type: :conflicts/
+      checker = /t\.enum +"conflicts", +array: true, +enum_type: "conflicts"/
       ActiveRecord::SchemaDumper.dump(connection, dump_io)
       expect(dump_io.string).to match checker
     end
 
     xit 'can have a default value as an array of symbols' do
       dump_io = StringIO.new
-      checker = /t\.enum +"types", +default: \[:A, :B\], +array: true, +enum_type: :types/
+      checker = /t\.enum +"types", +default: \[:A, :B\], +array: true, +enum_type: "types"/
       ActiveRecord::SchemaDumper.dump(connection, dump_io)
       expect(dump_io.string).to match checker
     end

data/spec/tests/enum_spec.rb

@@ -26,12 +26,6 @@ RSpec.describe 'Enum' do
   end
 
   context 'on migration' do
-    it 'can be created' do
-      connection.create_enum(:status, %i(foo bar))
-      expect(connection.type_exists?(:status)).to be_truthy
-      expect(connection.enum_values(:status)).to be_eql(['foo', 'bar'])
-    end
-
     it 'can be deleted' do
       connection.create_enum(:status, %i(foo bar))
       expect(connection.type_exists?(:status)).to be_truthy
@@ -46,16 +40,6 @@ RSpec.describe 'Enum' do
       expect(connection.type_exists?(:status)).to be_truthy
     end
 
-    it 'can have prefix' do
-      connection.create_enum(:status, %i(foo bar), prefix: true)
-      expect(connection.enum_values(:status)).to be_eql(['status_foo', 'status_bar'])
-    end
-
-    it 'can have suffix' do
-      connection.create_enum(:status, %i(foo bar), suffix: 'tst')
-      expect(connection.enum_values(:status)).to be_eql(['foo_tst', 'bar_tst'])
-    end
-
     it 'inserts values at the end' do
       connection.create_enum(:status, %i(foo bar))
       connection.add_enum_values(:status, %i(baz qux))
@@ -85,80 +69,6 @@ RSpec.describe 'Enum' do
     end
   end
 
-  context 'on table definition' do
-    subject { table_definition.new(connection, 'articles') }
-
-    it 'has the enum method' do
-      expect(subject).to respond_to(:enum)
-    end
-
-    it 'can be used in a single form' do
-      subject.enum('content_status')
-      expect(subject['content_status'].name).to be_eql('content_status')
-      expect(subject['content_status'].type).to be_eql(:content_status)
-    end
-
-    it 'can be used in a multiple form' do
-      subject.enum('foo', 'bar', 'baz', enum_type: :content_status)
-      expect(subject['foo'].type).to be_eql(:content_status)
-      expect(subject['bar'].type).to be_eql(:content_status)
-      expect(subject['baz'].type).to be_eql(:content_status)
-    end
-
-    it 'can have custom type' do
-      subject.enum('foo', enum_type: :content_status)
-      expect(subject['foo'].name).to be_eql('foo')
-      expect(subject['foo'].type).to be_eql(:content_status)
-    end
-
-    it 'can use the deprecated subtype option' do
-      subject.enum('foo', subtype: :content_status)
-      expect(subject['foo'].name).to be_eql('foo')
-      expect(subject['foo'].type).to be_eql(:content_status)
-    end
-
-    it 'raises StatementInvalid when type isn\'t defined' do
-      subject.enum('foo')
-      creation = connection.send(:schema_creation).accept subject
-      expect{ connection.execute creation }.to raise_error(ActiveRecord::StatementInvalid)
-    end
-  end
-
-  context 'on schema' do
-    it 'dumps when has it' do
-      dump_io = StringIO.new
-      ActiveRecord::SchemaDumper.dump(connection, dump_io)
-      expect(dump_io.string).to match /create_enum \"content_status\", \[/
-    end
-
-    it 'sorts the enum entries to better consistency' do
-      dump_io = StringIO.new
-      ActiveRecord::SchemaDumper.dump(connection, dump_io)
-      items = dump_io.string.scan(/create_enum "(\w+)"/).flatten
-      expect(items).to be_eql(items.sort)
-    end
-
-    it 'do not dump when has none' do
-      connection.drop_type(:content_status, force: :cascade)
-
-      dump_io = StringIO.new
-      ActiveRecord::SchemaDumper.dump(connection, dump_io)
-      expect(dump_io.string).not_to match /create_enum \"content_status\", \[/
-    end
-
-    it 'can be used on tables too' do
-      dump_io = StringIO.new
-      ActiveRecord::SchemaDumper.dump(connection, dump_io)
-      expect(dump_io.string).to match /t\.enum +"status", +enum_type: :content_status/
-    end
-
-    it 'can have a default value as symbol' do
-      dump_io = StringIO.new
-      ActiveRecord::SchemaDumper.dump(connection, dump_io)
-      expect(dump_io.string).to match /t\.enum +"role", +default: :visitor, +enum_type: :roles/
-    end
-  end
-
   context 'on value' do
     subject { Enum::ContentStatus }
     let(:values) { %w(created draft published archived) }

data/spec/tests/has_many_spec.rb

@@ -411,50 +411,4 @@ RSpec.describe 'HasMany' do
       expect { query.load }.not_to raise_error
     end
   end
-
-  context 'using uuid' do
-    let(:connection) { ActiveRecord::Base.connection }
-    let(:game) { Class.new(ActiveRecord::Base) }
-    let(:player) { Class.new(ActiveRecord::Base) }
-
-    # TODO: Set as a shred example
-    before do
-      connection.create_table(:players, id: :uuid) { |t| t.string :name }
-      connection.create_table(:games, id: :uuid) { |t| t.uuid :player_ids, array: true }
-
-      options = { anonymous_class: game, foreign_key: :player_ids }
-      options[:inverse_of] = false if Torque::PostgreSQL::AR610
-
-      game.table_name = 'games'
-      player.table_name = 'players'
-      player.has_many :games, array: true, **options
-    end
-
-    subject { player.create }
-
-    it 'loads associated records' do
-      expect(subject.games.to_sql).to match(Regexp.new(<<-SQL.squish))
-        SELECT "games"\\.\\* FROM "games"
-        WHERE \\(?"games"\\."player_ids" && ARRAY\\['#{subject.id}'\\]::uuid\\[\\]\\)?
-      SQL
-
-      expect(subject.games.load).to be_a(ActiveRecord::Associations::CollectionProxy)
-      expect(subject.games.to_a).to be_eql([])
-    end
-
-    it 'can preload records' do
-      5.times { game.create(player_ids: [subject.id]) }
-      entries = player.all.includes(:games).load
-
-      expect(entries.size).to be_eql(1)
-      expect(entries.first.games).to be_loaded
-      expect(entries.first.games.size).to be_eql(5)
-    end
-
-    it 'can joins records' do
-      query = player.all.joins(:games)
-      expect(query.to_sql).to match(/INNER JOIN "games"/)
-      expect { query.load }.not_to raise_error
-    end
-  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: torque-postgresql
 version: !ruby/object:Gem::Version
-  version: 2.2.4
+  version: 3.0.0
 platform: ruby
 authors:
 - Carlos Silva
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-04-11 00:00:00.000000000 Z
+date: 2022-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '7.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '7.0'
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -189,14 +189,15 @@ files:
 - lib/torque/postgresql/arel/select_manager.rb
 - lib/torque/postgresql/arel/visitors.rb
 - lib/torque/postgresql/associations.rb
-- lib/torque/postgresql/associations/association.rb
 - lib/torque/postgresql/associations/association_scope.rb
 - lib/torque/postgresql/associations/belongs_to_many_association.rb
 - lib/torque/postgresql/associations/builder.rb
 - lib/torque/postgresql/associations/builder/belongs_to_many.rb
 - lib/torque/postgresql/associations/builder/has_many.rb
+- lib/torque/postgresql/associations/foreign_association.rb
 - lib/torque/postgresql/associations/preloader.rb
 - lib/torque/postgresql/associations/preloader/association.rb
+- lib/torque/postgresql/associations/preloader/loader_query.rb
 - lib/torque/postgresql/attributes.rb
 - lib/torque/postgresql/attributes/builder.rb
 - lib/torque/postgresql/attributes/builder/enum.rb
@@ -232,7 +233,6 @@ files:
 - lib/torque/postgresql/relation/merger.rb
 - lib/torque/postgresql/schema_cache.rb
 - lib/torque/postgresql/version.rb
-- lib/torque/range.rb
 - spec/en.yml
 - spec/factories/authors.rb
 - spec/factories/comments.rb
@@ -279,7 +279,6 @@ files:
 - spec/tests/lazy_spec.rb
 - spec/tests/period_spec.rb
 - spec/tests/quoting_spec.rb
-- spec/tests/range_spec.rb
 - spec/tests/relation_spec.rb
 - spec/tests/table_inheritance_spec.rb
 homepage: https://github.com/crashtech/torque-postgresql
@@ -294,7 +293,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.6'
+      version: 2.7.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -352,6 +351,5 @@ test_files:
 - spec/tests/lazy_spec.rb
 - spec/tests/period_spec.rb
 - spec/tests/quoting_spec.rb
-- spec/tests/range_spec.rb
 - spec/tests/relation_spec.rb
 - spec/tests/table_inheritance_spec.rb

data/lib/torque/range.rb

@@ -1,20 +0,0 @@
-module Torque
-  module Range
-    def intersection(other)
-      raise ArgumentError, 'value must be a Range' unless other.kind_of?(Range)
-
-      new_min = self.cover?(other.min) ? other.min : other.cover?(min) ? min : nil
-      new_max = self.cover?(other.max) ? other.max : other.cover?(max) ? max : nil
-
-      new_min && new_max ? new_min..new_max : nil
-    end
-    alias_method :&, :intersection
-
-    def union(other)
-      raise ArgumentError, 'value must be a Range' unless other.kind_of?(Range)
-
-      ([min, other.min].min)..([max, other.max].max)
-    end
-    alias_method :|, :union
-  end
-end

data/spec/tests/range_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-RSpec.xdescribe 'Range' do
-  let(:sample) { (5..15) }
-
-  it 'has intersection' do
-    expect { sample.intersection(10) }.to raise_error(ArgumentError, /Range/)
-
-    result = sample & (10..15)
-    expect(result).to be_a(Range)
-    expect(result.min).to be_eql(10)
-    expect(result.max).to be_eql(15)
-
-    result = sample & (15..20)
-    expect(result).to be_a(Range)
-    expect(result.min).to be_eql(15)
-    expect(result.max).to be_eql(15)
-
-    result = sample & (0..10)
-    expect(result).to be_a(Range)
-    expect(result.min).to be_eql(5)
-    expect(result.max).to be_eql(10)
-
-    result = sample & (-10..0)
-    expect(result).to be_nil
-  end
-
-  it 'has union' do
-    expect { sample.union(10) }.to raise_error(ArgumentError, /Range/)
-
-    result = sample | (0..10)
-    expect(result).to be_a(Range)
-    expect(result.min).to be_eql(0)
-    expect(result.max).to be_eql(15)
-  end
-end