Fix array association inversion and records delete

Author: Carlos Silva

lib/torque/postgresql/associations/belongs_to_many_association.rb

@@ -47,7 +47,7 @@ def include?(record)
           return include_in_memory?(record) if record.new_record?
 
           (!target.empty? && target.include?(record)) ||
-            stale_state.include?(record.read_attribute(klass_attr))
+            stale_state&.include?(record.read_attribute(klass_attr))
         end
 
         def load_target
@@ -179,7 +179,7 @@ def read_records_ids(records)
           def ids_rewriter(ids, operator)
             list = owner[source_attr] ||= []
             list = list.public_send(operator, ids)
-            owner[source_attr] = list.uniq.compact
+            owner[source_attr] = list.uniq.compact.presence
 
             return if @_building_changes || !owner.persisted?
             owner.update_attribute(source_attr, list)
@@ -194,6 +194,10 @@ def concat_records(*)
             build_changes { super }
           end
 
+          def delete_or_destroy(*)
+            build_changes { super }
+          end
+
           def difference(a, b)
             a - b
           end

lib/torque/postgresql/reflection/abstract_reflection.rb

@@ -103,28 +103,6 @@ def arel_array_to_any(klass_attr, source_attr, klass_type, source_type)
 
             ::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 valid_inverse_reflection?(reflection)
-            end
-          end
       end
 
       ::ActiveRecord::Reflection::AbstractReflection.prepend(AbstractReflection)

lib/torque/postgresql/reflection/association_reflection.rb

@@ -24,6 +24,28 @@ def derive_foreign_key
             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)

spec/tests/belongs_to_many_spec.rb

@@ -200,6 +200,15 @@
       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
       subject.tags.concat(FactoryBot.create_list(:tag, 5))
       expect(subject.tags.size).to be_eql(5)
@@ -245,11 +254,15 @@
     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

spec/tests/has_many_spec.rb

@@ -291,6 +291,20 @@
       expect(record.tag_ids).to be_eql([subject.id])
     end
 
+    it 'can perist after accessed in after_create' do
+      other.belongs_to_many(:tags)
+      other.after_create { self.tags.to_a }
+
+      video = FactoryBot.create(:video)
+      subject.videos << video
+
+      expect(subject.reload.videos.size).to eql(1)
+      expect(video.reload.tags.size).to eql(1)
+
+      other.reset_callbacks(:create)
+      other._reflections = {}
+    end
+
     it 'can concat records' do
       FactoryBot.create(:video, tag_ids: [subject.id])
       expect(subject.videos.size).to be_eql(1)