torque-postgresql 2.4.2 → 3.0.0

data/lib/torque/postgresql/migration/command_recorder.rb

@@ -5,26 +5,16 @@ module Torque
     module Migration
       module CommandRecorder
 
-        # Records the rename operation for types
+        # Records the rename operation for types.
         def rename_type(*args, &block)
           record(:rename_type, args, &block)
         end
 
-        # Inverts the type rename operation
+        # Inverts the type name.
         def invert_rename_type(args)
           [:rename_type, args.reverse]
         end
 
-        # Records the creation of a schema
-        def create_schema(*args, &block)
-          record(:create_schema, args, &block)
-        end
-
-        # Inverts the creation of a schema
-        def invert_create_schema(args)
-          [:drop_schema, [args.first]]
-        end
-
         # Records the creation of the enum to be reverted.
         def create_enum(*args, &block)
           record(:create_enum, args, &block)

data/lib/torque/postgresql/railtie.rb

@@ -30,15 +30,11 @@ module Torque
           Torque::PostgreSQL::Attributes::Enum.lookup(name).sample
         end
 
-        # Define the exposed constant for both types of auxiliary statements
+        # Define the exposed constant for auxiliary statements
         if torque_config.auxiliary_statement.exposed_class.present?
           *ns, name = torque_config.auxiliary_statement.exposed_class.split('::')
           base = ns.present? ? Object.const_get(ns.join('::')) : Object
           base.const_set(name, Torque::PostgreSQL::AuxiliaryStatement)
-
-          *ns, name = torque_config.auxiliary_statement.exposed_recursive_class.split('::')
-          base = ns.present? ? Object.const_get(ns.join('::')) : Object
-          base.const_set(name, Torque::PostgreSQL::AuxiliaryStatement::Recursive)
         end
       end
     end

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

@@ -10,14 +10,22 @@ module Torque
         # :nodoc:
         def auxiliary_statements_values=(value); set_value(:auxiliary_statements, value); end
 
-        # Set use of an auxiliary statement
-        def with(*args, **settings)
-          spawn.with!(*args, **settings)
+        # Set use of an auxiliary statement already configurated on the model
+        def with(*args)
+          spawn.with!(*args)
         end
 
         # Like #with, but modifies relation in place.
-        def with!(*args, **settings)
-          instantiate_auxiliary_statements(*args, **settings)
+        def with!(*args)
+          options = args.extract_options!
+          args.each do |table|
+            instance = table.is_a?(Class) && table < PostgreSQL::AuxiliaryStatement \
+              ? table.new(options) \
+              : PostgreSQL::AuxiliaryStatement.instantiate(table, self, options)
+
+            self.auxiliary_statements_values += [instance]
+          end
+
           self
         end
 
@@ -39,23 +47,8 @@ module Torque
           # Hook arel build to add the distinct on clause
           def build_arel(*)
             arel = super
-            type = auxiliary_statement_type
-            sub_queries = build_auxiliary_statements(arel)
-            sub_queries.nil? ? arel : arel.with(*type, *sub_queries)
-          end
-
-          # Instantiate one or more auxiliary statements for the given +klass+
-          def instantiate_auxiliary_statements(*args, **options)
-            klass = PostgreSQL::AuxiliaryStatement
-            klass = klass::Recursive if options.delete(:recursive).present?
-
-            self.auxiliary_statements_values += args.map do |table|
-              if table.is_a?(Class) && table < klass
-                table.new(**options)
-              else
-                klass.instantiate(table, self, **options)
-              end
-            end
+            subqueries = build_auxiliary_statements(arel)
+            subqueries.nil? ? arel : arel.with(subqueries)
           end
 
           # Build all necessary data for auxiliary statements
@@ -66,12 +59,6 @@ module Torque
             end
           end
 
-          # Return recursive if any auxiliary statement is recursive
-          def auxiliary_statement_type
-            klass = PostgreSQL::AuxiliaryStatement::Recursive
-            :recursive if auxiliary_statements_values.any?(klass)
-          end
-
           # Throw an error showing that an auxiliary statement of the given
           # table name isn't defined
           def auxiliary_statement_error(name)

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)
@@ -117,19 +118,13 @@ module Torque
         scopes = scoped_class.scan(/(?:::)?[A-Z][a-z]+/)
         scopes.unshift('Object::')
 
-        # Check if the table name comes with a schema
-        if table_name.include?('.')
-          schema, table_name = table_name.split('.')
-          scopes.insert(1, schema.camelize) if schema != 'public'
-        end
-
         # Consider the maximum namespaced possible model name
         max_name = table_name.tr('_', '/').camelize.split(/(::)/)
         max_name[-1] = max_name[-1].singularize
 
         # 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.4.2'
+    VERSION = '3.0.0'
   end
 end

data/lib/torque/postgresql.rb

@@ -20,13 +20,12 @@ require 'torque/postgresql/associations'
 require 'torque/postgresql/attributes'
 require 'torque/postgresql/autosave_association'
 require 'torque/postgresql/auxiliary_statement'
+require 'torque/postgresql/base'
 require 'torque/postgresql/inheritance'
-require 'torque/postgresql/base'# Needs to be after inheritance
 require 'torque/postgresql/insert_all'
 require 'torque/postgresql/migration'
 require 'torque/postgresql/relation'
 require 'torque/postgresql/reflection'
 require 'torque/postgresql/schema_cache'
-require 'torque/postgresql/table_name'
 
 require 'torque/postgresql/railtie' if defined?(Rails)

data/lib/torque-postgresql.rb

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

data/spec/schema.rb

@@ -20,16 +20,13 @@ ActiveRecord::Schema.define(version: version) do
   enable_extension "pgcrypto"
   enable_extension "plpgsql"
 
-  # Custom schemas used in this database.
-  create_schema "internal", force: :cascade
-
   # 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"
@@ -69,11 +66,6 @@ ActiveRecord::Schema.define(version: version) do
     t.enum     "specialty", enum_type: :specialties
   end
 
-  create_table "categories", force: :cascade do |t|
-    t.integer  "parent_id"
-    t.string   "title"
-  end
-
   create_table "texts", force: :cascade do |t|
     t.integer  "user_id"
     t.string   "content"
@@ -91,7 +83,6 @@ ActiveRecord::Schema.define(version: version) do
   end
 
   create_table "courses", force: :cascade do |t|
-    t.integer  "category_id"
     t.string   "title",      null: false
     t.interval "duration"
     t.enum     "types", enum_type: :types, array: true
@@ -126,13 +117,6 @@ ActiveRecord::Schema.define(version: version) do
     t.datetime "updated_at", null: false
   end
 
-  create_table "users", schema: "internal", force: :cascade do |t|
-    t.string   "email"
-    t.datetime "created_at", null: false
-    t.datetime "updated_at", null: false
-    t.index ["email"], name: "index_internal_users_on_email", unique: true
-  end
-
   create_table "activities", force: :cascade do |t|
     t.integer  "author_id"
     t.string   "title"

data/spec/spec_helper.rb

@@ -22,7 +22,7 @@ cleaner = ->() do
 end
 
 load File.join('schema.rb')
-Dir.glob(File.join('spec', '{models,factories,mocks}', '**', '*.rb')) do |file|
+Dir.glob(File.join('spec', '{models,factories,mocks}', '*.rb')) do |file|
   require file[5..-4]
 end
 
@@ -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