torque-postgresql 2.0.3 → 2.1.1

data/lib/torque/postgresql/insert_all.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module InsertAll
+      attr_reader :where
+
+      def initialize(*args, where: nil, **xargs)
+        super(*args, **xargs)
+
+        @where = where
+      end
+    end
+
+    module InsertAll::Builder
+      delegate :where, to: :insert_all
+
+      def where_condition?
+        !where.nil?
+      end
+    end
+
+    ActiveRecord::InsertAll.prepend InsertAll
+    ActiveRecord::InsertAll::Builder.include InsertAll::Builder
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Torque
   module PostgreSQL
     module Migration

data/lib/torque/postgresql/railtie.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Torque
   module PostgreSQL
     # = Torque PostgreSQL Railtie

data/lib/torque/postgresql/reflection.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'reflection/abstract_reflection'
 require_relative 'reflection/association_reflection'
 require_relative 'reflection/belongs_to_many_reflection'

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

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 module Torque
   module PostgreSQL
     module Reflection
       module AbstractReflection
         AREL_ATTR = ::Arel::Attributes::Attribute
 
-        ARR_NO_CAST = 'bigint'.freeze
-        ARR_CAST = 'bigint[]'.freeze
+        ARR_NO_CAST = 'bigint'
+        ARR_CAST = 'bigint[]'
 
         # Check if the foreign key actually exists
         def connected_through_array?
@@ -68,11 +70,18 @@ module Torque
           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
+        end
+
         private
 
           def build_id_constraint_between(table, foreign_table)
-            klass_attr  = table[join_keys.key.to_s]
-            source_attr = foreign_table[join_keys.foreign_key.to_s]
+            klass_attr  = table[join_primary_key]
+            source_attr = foreign_table[join_foreign_key]
 
             build_id_constraint(klass_attr, source_attr)
           end
@@ -94,30 +103,6 @@ module Torque
 
             ::Arel::Nodes::NamedFunction.new('ANY', [source_attr])
           end
-
-          # 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)
-              inverse_name = ActiveSupport::Inflector.pluralize(inverse_name)
-              inverse_name = inverse_name.to_sym
-
-              begin
-                reflection = klass._reflect_on_association(inverse_name)
-              rescue NameError
-                # Give up: we couldn't compute the klass type so we won't be able
-                # to find any associations either.
-                reflection = false
-              end
-
-              return inverse_name if reflection.connected_through_array? &&
-                valid_inverse_reflection?(reflection)
-            end
-          end
-
       end
 
       ::ActiveRecord::Reflection::AbstractReflection.prepend(AbstractReflection)

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Torque
   module PostgreSQL
     module Reflection
@@ -22,6 +24,28 @@ module Torque
             result
           end
 
+          # 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)
+              inverse_name = ActiveSupport::Inflector.pluralize(inverse_name)
+              inverse_name = inverse_name.to_sym
+
+              begin
+                reflection = klass._reflect_on_association(inverse_name)
+              rescue NameError
+                # Give up: we couldn't compute the klass type so we won't be able
+                # to find any associations either.
+                reflection = false
+              end
+
+              return inverse_name if valid_inverse_reflection?(reflection)
+            end
+          end
+
       end
 
       ::ActiveRecord::Reflection::AssociationReflection.prepend(AssociationReflection)

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Torque
   module PostgreSQL
     module Reflection

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Torque
   module PostgreSQL
     module Reflection

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Torque
   module PostgreSQL
     module Reflection

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Torque
   module PostgreSQL
     module Reflection

data/lib/torque/postgresql/relation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'relation/distinct_on'
 require_relative 'relation/auxiliary_statement'
 require_relative 'relation/inheritance'
@@ -48,12 +50,12 @@ module Torque
           when String
             ::Arel.sql(klass.send(:sanitize_sql, item.to_s))
           when Symbol
-            base ? base.arel_attribute(item) : klass.arel_attribute(item)
+            base ? base.arel_table[item] : klass.arel_table[item]
           when Array
             resolve_column(item, base)
           when Hash
             raise ArgumentError, 'Unsupported Hash for attributes on third level' if base
-            item.map { |key, other_list| resolve_column(Array.wrap(other_list), key) }
+            item.map { |key, other_list| resolve_column(other_list, key) }
           else
             raise ArgumentError, "Unsupported argument type: #{value} (#{value.class})"
           end
@@ -65,8 +67,8 @@ module Torque
         return unless relation
 
         table = predicate_builder.send(:table)
-        if table.associated_with?(relation)
-          table.associated_table(relation).send(:klass)
+        if table.associated_with?(relation.to_s)
+          table.associated_table(relation.to_s).send(:klass)
         else
           raise ArgumentError, "Relation for #{relation} not found on #{klass}"
         end
@@ -138,14 +140,16 @@ module Torque
     ActiveRecord::QueryMethods::VALID_UNSCOPING_VALUES += %i[cast_records itself_only
       distinct_on auxiliary_statements]
 
-    Relation::SINGLE_VALUE_METHODS.each do |value|
-      ActiveRecord::QueryMethods::DEFAULT_VALUES[value] = nil \
-        if ActiveRecord::QueryMethods::DEFAULT_VALUES[value].nil?
-    end
+    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
+      Relation::MULTI_VALUE_METHODS.each do |value|
+        ActiveRecord::QueryMethods::DEFAULT_VALUES[value] ||= \
+          ActiveRecord::QueryMethods::FROZEN_EMPTY_ARRAY
+      end
     end
 
     $VERBOSE = warn_level

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Torque
   module PostgreSQL
     module Relation
@@ -34,7 +36,10 @@ module Torque
         # attributes as well
         def bound_attributes
           visitor = ::Arel::Visitors::PostgreSQL.new(ActiveRecord::Base.connection)
-          visitor.accept(self.arel.ast, ::Arel::Collectors::Bind.new).value
+          visitor.accept(self.arel.ast, ::Arel::Collectors::Composite.new(
+            ::Arel::Collectors::SQLString.new,
+            ::Arel::Collectors::Bind.new,
+          )).value.last
         end
 
         private

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Torque
   module PostgreSQL
     module Relation

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Torque
   module PostgreSQL
     module Relation

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Torque
   module PostgreSQL
     module Relation

data/lib/torque/postgresql/schema_cache.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Torque
   module PostgreSQL
     LookupError = Class.new(ArgumentError)

data/lib/torque/postgresql/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Torque
   module PostgreSQL
-    VERSION = '2.0.3'
+    VERSION = '2.1.1'
   end
 end

data/spec/schema.rb

@@ -11,7 +11,7 @@
 # It's strongly recommended that you check this file into your version control system.
 
 begin
-  version = 61
+  version = 63
 
   raise SystemExit if ActiveRecord::Migrator.current_version == version
   ActiveRecord::Schema.define(version: version) do
@@ -74,6 +74,7 @@ begin
     create_table "comments", force: :cascade do |t|
       t.integer "user_id",    null: false
       t.integer "comment_id"
+      t.integer "video_id"
       t.text    "content",    null: false
       t.string  "kind"
       t.index ["user_id"], name: "index_comments_on_user_id", using: :btree
@@ -83,7 +84,7 @@ begin
     create_table "courses", force: :cascade do |t|
       t.string   "title",      null: false
       t.interval "duration"
-      t.enum     "types", subtype: :types, array: true, default: [:A, :B]
+      t.enum     "types", subtype: :types, array: true
       t.datetime "created_at", null: false
       t.datetime "updated_at", null: false
     end

data/spec/tests/arel_spec.rb

@@ -25,7 +25,9 @@ RSpec.describe 'Arel' do
       klass_name = operator.to_s.camelize
 
       context "##{operator}" do
-        let(:instance) { attribute.public_send(operator, value) }
+        let(:instance) do
+          attribute.public_send(operator, value.is_a?(Array) ? ::Arel.array(value) : value)
+        end
 
         context 'for attribute' do
           let(:klass) { ::Arel::Nodes.const_get(klass_name) }

data/spec/tests/belongs_to_many_spec.rb

@@ -26,9 +26,13 @@ RSpec.describe 'BelongsToMany' do
     let(:other) { Tag }
     let(:initial) { FactoryBot.create(:tag) }
 
-    before { Video.belongs_to_many :tags }
+    before { Video.belongs_to_many(:tags) }
     subject { Video.create(title: 'A') }
-    after { Video._reflections = {} }
+
+    after do
+      Video.reset_callbacks(:save)
+      Video._reflections = {}
+    end
 
     it 'has the method' do
       expect(subject).to respond_to(:tags)
@@ -93,13 +97,64 @@ RSpec.describe 'BelongsToMany' do
       expect(records.map(&:id).sort).to be_eql(ids.sort)
     end
 
+    it 'can create the owner record with direct set items' do
+      # Having another association would break this test due to how
+      # +@new_record_before_save+ is set on autosave association
+      Video.has_many(:comments)
+
+      record = Video.create(title: 'A', tags: [initial])
+      record.reload
+
+      expect(record.tags.size).to be_eql(1)
+      expect(record.tags.first.id).to be_eql(initial.id)
+    end
+
+    it 'can keep record changes accordingly' do
+      expect(subject.tags.count).to be_eql(0)
+
+      local_previous_changes = nil
+      local_saved_changes = nil
+
+      Video.after_commit do
+        local_previous_changes = self.previous_changes.dup
+        local_saved_changes = self.saved_changes.dup
+      end
+
+      subject.update(title: 'B')
+
+      expect(local_previous_changes).to include('title')
+      expect(local_saved_changes).to include('title')
+
+      subject.tags = FactoryBot.create_list(:tag, 5)
+      subject.update(title: 'C', url: 'X')
+      subject.reload
+
+      expect(local_previous_changes).to include('title', 'url')
+      expect(local_saved_changes).to include('title', 'url')
+      expect(local_previous_changes).not_to include('tag_ids')
+      expect(local_saved_changes).not_to include('tag_ids')
+      expect(subject.tag_ids.size).to be_eql(5)
+      expect(subject.tags.count).to be_eql(5)
+    end
+
+    it 'can assign the record ids during before callback' do
+      Video.before_save { self.tags = FactoryBot.create_list(:tag, 5) }
+
+      record = Video.create(title: 'A')
+
+      expect(Tag.count).to be_eql(5)
+      expect(record.tag_ids.size).to be_eql(5)
+      expect(record.tags.count).to be_eql(5)
+    end
+
     it 'can build an associated record' do
       record = subject.tags.build(name: 'Test')
       expect(record).to be_a(other)
       expect(record).not_to be_persisted
       expect(record.name).to be_eql('Test')
+      expect(subject.tags.target).to be_eql([record])
 
-      expect(subject.save).to be_truthy
+      expect(subject.save && subject.reload).to be_truthy
       expect(subject.tag_ids).to be_eql([record.id])
       expect(subject.tags.size).to be_eql(1)
     end
@@ -120,7 +175,7 @@ RSpec.describe 'BelongsToMany' do
       expect(subject.tags.size).to be_eql(1)
 
       subject.tags.concat(other.new(name: 'Test'))
-      subject.tags.reload
+      subject.reload
 
       expect(subject.tags.size).to be_eql(2)
       expect(subject.tag_ids.size).to be_eql(2)
@@ -131,10 +186,27 @@ RSpec.describe 'BelongsToMany' do
       subject.tags << FactoryBot.create(:tag)
       expect(subject.tags.size).to be_eql(1)
 
-      subject.tags.replace([other.new(name: 'Test 1'), other.new(name: 'Test 2')])
-      expect(subject.tags.size).to be_eql(2)
+      subject.tags = [other.new(name: 'Test 1')]
+      subject.reload
+
+      expect(subject.tags.size).to be_eql(1)
       expect(subject.tags[0].name).to be_eql('Test 1')
-      expect(subject.tags[1].name).to be_eql('Test 2')
+
+      subject.tags.replace([other.new(name: 'Test 2'), other.new(name: 'Test 3')])
+      subject.reload
+
+      expect(subject.tags.size).to be_eql(2)
+      expect(subject.tags[0].name).to be_eql('Test 2')
+      expect(subject.tags[1].name).to be_eql('Test 3')
+    end
+
+    it 'can delete specific records' do
+      subject.tags << initial
+      expect(subject.tags.size).to be_eql(1)
+
+      subject.tags.delete(initial)
+      expect(subject.tags.size).to be_eql(0)
+      expect(subject.reload.tags.size).to be_eql(0)
     end
 
     it 'can delete all records' do
@@ -153,6 +225,17 @@ RSpec.describe 'BelongsToMany' do
       expect(subject.tags.size).to be_eql(0)
     end
 
+    it 'can clear the array' do
+      record = Video.create(title: 'B', tags: [initial])
+      expect(record.tags.size).to be_eql(1)
+
+      record.update(tag_ids: [])
+      record.reload
+
+      expect(record.tag_ids).to be_nil
+      expect(record.tags.size).to be_eql(0)
+    end
+
     it 'can have sum operations' do
       records = FactoryBot.create_list(:tag, 5)
       subject.tags.concat(records)
@@ -182,11 +265,15 @@ RSpec.describe 'BelongsToMany' do
     it 'can check if a record is included on the list' do
       outside = FactoryBot.create(:tag)
       inside = FactoryBot.create(:tag)
+
+      expect(subject.tags).not_to be_include(inside)
+      expect(subject.tags).not_to be_include(outside)
+
       subject.tags << inside
 
       expect(subject.tags).to respond_to(:include?)
-      expect(subject.tags.include?(inside)).to be_truthy
-      expect(subject.tags.include?(outside)).to be_falsey
+      expect(subject.tags).to be_include(inside)
+      expect(subject.tags).not_to be_include(outside)
     end
 
     it 'can append records' do
@@ -194,6 +281,9 @@ RSpec.describe 'BelongsToMany' do
       expect(subject.tags.size).to be_eql(1)
 
       subject.tags << other.new(name: 'Test 2')
+      subject.update(title: 'B')
+      subject.reload
+
       expect(subject.tags.size).to be_eql(2)
       expect(subject.tags.last.name).to be_eql('Test 2')
     end
@@ -208,10 +298,18 @@ RSpec.describe 'BelongsToMany' do
 
     it 'can reload records' do
       expect(subject.tags.size).to be_eql(0)
-      subject.tags << FactoryBot.create(:tag)
+      new_tag = FactoryBot.create(:tag)
+      subject.tags << new_tag
 
       subject.tags.reload
       expect(subject.tags.size).to be_eql(1)
+      expect(subject.tags.first.id).to be_eql(new_tag.id)
+
+      record = Video.create(title: 'B', tags: [new_tag])
+      record.reload
+
+      expect(record.tags.size).to be_eql(1)
+      expect(record.tags.first.id).to be_eql(new_tag.id)
     end
 
     it 'can preload records' do
@@ -231,11 +329,39 @@ RSpec.describe 'BelongsToMany' do
       expect { query.load }.not_to raise_error
     end
 
-    context "When record is not persisted" do
+    context 'When the attribute has a default value' do
+      after(:all) { Video.reset_column_information }
+      let(:sql) { %{ALTER TABLE "videos" ALTER COLUMN "tag_ids" SET DEFAULT '{}'::bigint[]} }
+
+      before do
+        Video.connection.execute(sql)
+        Video.reset_column_information
+      end
+
+      it 'will always return the column default value' do
+        expect(subject.tag_ids).to be_a(Array)
+        expect(subject.tag_ids).to be_empty
+      end
+
+      it 'will keep the value as an array even when the association is cleared' do
+        records = FactoryBot.create_list(:tag, 5)
+        subject.tags.concat(records)
+
+        subject.reload
+        expect(subject.tag_ids).to be_a(Array)
+        expect(subject.tag_ids).not_to be_empty
+
+        subject.tags.clear
+        subject.reload
+        expect(subject.tag_ids).to be_a(Array)
+        expect(subject.tag_ids).to be_empty
+      end
+    end
+
+    context 'When record is not persisted' do
       let(:initial) { FactoryBot.create(:tag) }
-      before { Video.belongs_to_many :tags }
+
       subject { Video.new(title: 'A', tags: [initial]) }
-      after { Video._reflections = {} }
 
       it 'loads associated records' do
         expect(subject.tags.load).to be_a(ActiveRecord::Associations::CollectionProxy)