torque-postgresql 2.0.5 → 2.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fe8259f8bb0f4c8c67c32919ec2bc2ca448c5372857670ed5fbd4d932e3160d6
-  data.tar.gz: 3786a17977e0d4ffd81c1521c9e469fd411b6d15b413866941adc911beb8c2dd
+  metadata.gz: bd314ab034c3d38a227829faf2d706b13625a5e4cc6393004f6dbe2890e784a8
+  data.tar.gz: 035b0fc92e1ea2aedb507c18094e66025c0fe98838f8553f3abc64764a0b2f03
 SHA512:
-  metadata.gz: f35b0eb94b260cc5c5c9d08a47dcba841d9044c9acc52d30b0ad13b1e0a6ecbe2ef10ca940828870fbf5f04b387827b9c56db43523e0585f77f950a72e368b51
-  data.tar.gz: a3b899a4c7a26f9ff9a6a9af7f0d41a6ed193e96a76d96ae17a2423eb0b4bc6ea59138684cd324a28ccfad7374528c1cb72d4ae89a0ad710ce66655d3e355e50
+  metadata.gz: 6eeaffde8209891fee13de7518acea135cfe5f35ecbc5aa59124faad208ed0545a24c2ffb993f10eb5e306c2ccb96036e1dbc812a11177ecdda5e3ead62e0dd7
+  data.tar.gz: ad55cf8b8a5e9de71575c12e8452d440439529258752ceceb95da17111991b8a9ad90101806ab328d5993d328bec69a71feb4cc6b85431c9802d0c225557dbb5

data/lib/torque/postgresql.rb

@@ -18,6 +18,7 @@ require 'torque/postgresql/arel'
 require 'torque/postgresql/adapter'
 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'

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

@@ -78,6 +78,10 @@ module Torque
 
             # Scenic integration
             views(stream) if defined?(::Scenic)
+
+            # FX integration
+            functions(stream) if defined?(::Fx::SchemaDumper::Function)
+            triggers(stream) if defined?(::Fx::SchemaDumper::Trigger)
           end
 
           # Dump user defined types like enum

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

@@ -5,6 +5,8 @@ module Torque
     module Associations
       module Association
 
+        # There is no problem of adding temporary items on target because
+        # CollectionProxy will handle memory and persisted relationship
         def inversed_from(record)
           return super unless reflection.connected_through_array?
 
@@ -13,19 +15,20 @@ module Torque
           @inversed = self.target.present?
         end
 
+        # The binds and the cache are getting mixed and caching the wrong query
         def skip_statement_cache?(*)
           super || reflection.connected_through_array?
         end
 
         private
 
+          # This is mainly for the has many when connect through an array to add
+          # its id to the list of the inverse belongs to many association
           def set_owner_attributes(record)
             return super unless reflection.connected_through_array?
 
             add_id = owner[reflection.active_record_primary_key]
-            record_fk = reflection.foreign_key
-
-            list = record[record_fk] ||= []
+            list = record[reflection.foreign_key] ||= []
             list.push(add_id) unless list.include?(add_id)
           end
 

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

@@ -9,10 +9,68 @@ module Torque
       class BelongsToManyAssociation < ::ActiveRecord::Associations::CollectionAssociation
         include ::ActiveRecord::Associations::ForeignAssociation
 
+        ## CUSTOM
+        def ids_reader
+          if loaded?
+            target.pluck(reflection.association_primary_key)
+          elsif !target.empty?
+            load_target.pluck(reflection.association_primary_key)
+          else
+            stale_state
+          end
+        end
+
+        def ids_writer(ids)
+          owner.write_attribute(source_attr, ids.presence)
+          return unless owner.persisted? && owner.attribute_changed?(source_attr)
+
+          owner.update_attribute(source_attr, ids.presence)
+        end
+
+        def size
+          if loaded?
+            target.size
+          elsif !target.empty?
+            unsaved_records = target.select(&:new_record?)
+            unsaved_records.size + stale_state.size
+          else
+            stale_state&.size || 0
+          end
+        end
+
+        def empty?
+          size.zero?
+        end
+
+        def include?(record)
+          return false unless record.is_a?(reflection.klass)
+          return include_in_memory?(record) if record.new_record?
+
+          (!target.empty? && target.include?(record)) ||
+            stale_state&.include?(record.read_attribute(klass_attr))
+        end
+
+        def load_target
+          if stale_target? || find_target?
+            @target = merge_target_lists(find_target, target)
+          end
+
+          loaded!
+          target
+        end
+
+        def build_changes
+          @_building_changes = true
+          yield.tap { ids_writer(ids_reader) }
+        ensure
+          @_building_changes = nil
+        end
+
+        ## HAS MANY
         def handle_dependency
           case options[:dependent]
           when :restrict_with_exception
-            raise ::ActiveRecord::DeleteRestrictionError.new(reflection.name) unless empty?
+            raise ActiveRecord::DeleteRestrictionError.new(reflection.name) unless empty?
 
           when :restrict_with_error
             unless empty?
@@ -22,86 +80,89 @@ module Torque
             end
 
           when :destroy
-            # No point in executing the counter update since we're going to destroy the parent anyway
             load_target.each { |t| t.destroyed_by_association = reflection }
             destroy_all
+          when :destroy_async
+            load_target.each do |t|
+              t.destroyed_by_association = reflection
+            end
+
+            unless target.empty?
+              association_class = target.first.class
+              primary_key_column = association_class.primary_key.to_sym
+
+              ids = target.collect do |assoc|
+                assoc.public_send(primary_key_column)
+              end
+
+              enqueue_destroy_association(
+                owner_model_name: owner.class.to_s,
+                owner_id: owner.id,
+                association_class: association_class.to_s,
+                association_ids: ids,
+                association_primary_key_column: primary_key_column,
+                ensuring_owner_was_method: options.fetch(:ensuring_owner_was, nil)
+              )
+            end
           else
             delete_all
           end
         end
 
-        def ids_reader
-          owner[source_attr]
-        end
-
-        def ids_writer(new_ids)
-          column = source_attr
-          command = owner.persisted? ? :update_column : :write_attribute
-          owner.public_send(command, column, new_ids.presence)
-          @association_scope = nil
-        end
-
         def insert_record(record, *)
-          super
-
-          attribute = (ids_reader || owner[source_attr] = [])
-          attribute.push(record[klass_attr])
-          record
+          super.tap do |saved|
+            ids_rewriter(record.read_attribute(klass_attr), :<<) if saved
+          end
         end
 
-        def empty?
-          size.zero?
-        end
-
-        def include?(record)
-          list = owner[source_attr]
-          ids_reader && ids_reader.include?(record[klass_attr])
+        ## BELONGS TO
+        def default(&block)
+          writer(owner.instance_exec(&block)) if reader.nil?
         end
 
         private
 
-          # Returns the number of records in this collection, which basically
-          # means count the number of entries in the +primary_key+
-          def count_records
-            ids_reader&.size || (@target ||= []).size
+          ## CUSTOM
+          def _create_record(attributes, raises = false, &block)
+            if attributes.is_a?(Array)
+              attributes.collect { |attr| _create_record(attr, raises, &block) }
+            else
+              build_record(attributes, &block).tap do |record|
+                transaction do
+                  result = nil
+                  add_to_target(record) do
+                    result = insert_record(record, true, raises) { @_was_loaded = loaded? }
+                  end
+                  raise ActiveRecord::Rollback unless result
+                end
+              end
+            end
           end
 
-          # When the idea is to nulligy the association, then just set the owner
+          # When the idea is to nullify the association, then just set the owner
           # +primary_key+ as empty
-          def delete_count(method, scope, ids = nil)
-            ids ||= scope.pluck(klass_attr)
-            scope.delete_all if method == :delete_all
-            remove_stash_records(ids)
+          def delete_count(method, scope, ids)
+            size_cache = scope.delete_all if method == :delete_all
+            (size_cache || ids.size).tap { ids_rewriter(ids, :-) }
           end
 
           def delete_or_nullify_all_records(method)
-            delete_count(method, scope)
+            delete_count(method, scope, ids_reader)
           end
 
           # Deletes the records according to the <tt>:dependent</tt> option.
           def delete_records(records, method)
-            ids = Array.wrap(records).each_with_object(klass_attr).map(&:[])
+            ids = read_records_ids(records)
 
             if method == :destroy
               records.each(&:destroy!)
-              remove_stash_records(ids)
+              ids_rewriter(ids, :-)
             else
               scope = self.scope.where(klass_attr => records)
               delete_count(method, scope, ids)
             end
           end
 
-          def concat_records(*)
-            result = super
-            ids_writer(ids_reader)
-            result
-          end
-
-          def remove_stash_records(ids)
-            return if ids_reader.nil?
-            ids_writer(ids_reader - Array.wrap(ids))
-          end
-
           def source_attr
             reflection.foreign_key
           end
@@ -110,6 +171,33 @@ module Torque
             reflection.active_record_primary_key
           end
 
+          def read_records_ids(records)
+            return unless records.present?
+            Array.wrap(records).each_with_object(klass_attr).map(&:read_attribute).presence
+          end
+
+          def ids_rewriter(ids, operator)
+            list = owner[source_attr] ||= []
+            list = list.public_send(operator, ids)
+            owner[source_attr] = list.uniq.compact.presence
+
+            return if @_building_changes || !owner.persisted?
+            owner.update_attribute(source_attr, list)
+          end
+
+          ## HAS MANY
+          def replace_records(*)
+            build_changes { super }
+          end
+
+          def concat_records(*)
+            build_changes { super }
+          end
+
+          def delete_or_destroy(*)
+            build_changes { super }
+          end
+
           def difference(a, b)
             a - b
           end
@@ -117,6 +205,28 @@ module Torque
           def intersection(a, b)
             a & b
           end
+
+          ## BELONGS TO
+          def scope_for_create
+            super.except!(klass.primary_key)
+          end
+
+          def find_target?
+            !loaded? && foreign_key_present? && klass
+          end
+
+          def foreign_key_present?
+            stale_state.present?
+          end
+
+          def invertible_for?(record)
+            inverse = inverse_reflection_for(record)
+            inverse && (inverse.has_many? && inverse.connected_through_array?)
+          end
+
+          def stale_state
+            owner.read_attribute(source_attr)
+          end
       end
 
       ::ActiveRecord::Associations.const_set(:BelongsToManyAssociation, BelongsToManyAssociation)

data/lib/torque/postgresql/associations/builder/belongs_to_many.rb

@@ -57,12 +57,9 @@ module Torque
               end
             end
 
-            unless reflection.counter_cache_column
-              model.after_create callback.call(:saved_changes), if: :saved_changes?
-              model.after_destroy callback.call(:changes_to_save)
-            end
-
+            model.after_create callback.call(:saved_changes), if: :saved_changes?
             model.after_update callback.call(:saved_changes), if: :saved_changes?
+            model.after_destroy callback.call(:changes_to_save)
             model.after_touch callback.call(:changes_to_save)
           end
 
@@ -97,6 +94,10 @@ module Torque
             end
           end
 
+          def self.add_destroy_callbacks(model, reflection)
+            model.after_destroy lambda { |o| o.association(reflection.name).handle_dependency }
+          end
+
           def self.define_validations(model, reflection)
             if reflection.options.key?(:required)
               reflection.options[:optional] = !reflection.options.delete(:required)

data/lib/torque/postgresql/autosave_association.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module AutosaveAssociation
+      module ClassMethods
+        # Since belongs to many is a collection, the callback would normally go
+        # to +after_create+. However, since it is a +belongs_to+ kind of
+        # association, it neds to be executed +before_save+
+        def add_autosave_association_callbacks(reflection)
+          return super unless reflection.macro.eql?(:belongs_to_many)
+
+          save_method = :"autosave_associated_records_for_#{reflection.name}"
+          define_non_cyclic_method(save_method) do
+            save_belongs_to_many_association(reflection)
+          end
+
+          before_save(save_method)
+
+          define_autosave_validation_callbacks(reflection)
+        end
+      end
+
+      # Ensure the right way to execute +save_collection_association+ and also
+      # keep it as a single change using +build_changes+
+      def save_belongs_to_many_association(reflection)
+        previously_new_record_before_save = (@new_record_before_save ||= false)
+        @new_record_before_save = new_record?
+
+        association = association_instance_get(reflection.name)
+        association&.build_changes { save_collection_association(reflection) }
+      rescue ::ActiveRecord::RecordInvalid
+        throw(:abort)
+      ensure
+        @new_record_before_save = previously_new_record_before_save
+      end
+    end
+
+    ::ActiveRecord::Base.singleton_class.prepend(AutosaveAssociation::ClassMethods)
+    ::ActiveRecord::Base.include(AutosaveAssociation)
+  end
+end

data/lib/torque/postgresql/base.rb

@@ -200,8 +200,9 @@ module Torque
         #   belongs_to_many :tags, dependent: :nullify
         #   belongs_to_many :tags, required: true, touch: true
         #   belongs_to_many :tags, default: -> { Tag.default }
-        def belongs_to_many(name, scope = nil, **options)
-          reflection = Associations::Builder::BelongsToMany.build(self, name, scope, options)
+        def belongs_to_many(name, scope = nil, **options, &extension)
+          klass = Associations::Builder::BelongsToMany
+          reflection = klass.build(self, name, scope, options, &extension)
           ::ActiveRecord::Reflection.add_reflection(self, name, reflection)
         end
 

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

@@ -103,29 +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

@@ -24,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/version.rb

@@ -2,6 +2,6 @@
 
 module Torque
   module PostgreSQL
-    VERSION = '2.0.5'
+    VERSION = '2.0.6'
   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 = 62
+  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

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
@@ -182,11 +254,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 +270,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 +287,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
@@ -233,9 +320,8 @@ RSpec.describe 'BelongsToMany' do
 
     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)

data/spec/tests/has_many_spec.rb

@@ -291,6 +291,20 @@ RSpec.describe 'HasMany' do
       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)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: torque-postgresql
 version: !ruby/object:Gem::Version
-  version: 2.0.5
+  version: 2.0.6
 platform: ruby
 authors:
 - Carlos Silva
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-01-27 00:00:00.000000000 Z
+date: 2021-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -211,6 +211,7 @@ files:
 - lib/torque/postgresql/attributes/enum_set.rb
 - lib/torque/postgresql/attributes/lazy.rb
 - lib/torque/postgresql/attributes/period.rb
+- lib/torque/postgresql/autosave_association.rb
 - lib/torque/postgresql/auxiliary_statement.rb
 - lib/torque/postgresql/auxiliary_statement/settings.rb
 - lib/torque/postgresql/base.rb
@@ -332,10 +333,9 @@ test_files:
 - spec/factories/videos.rb
 - spec/tests/geometric_builder_spec.rb
 - spec/tests/range_spec.rb
-- spec/tests/table_inheritance_spec.rb
+- spec/tests/arel_spec.rb
 - spec/tests/enum_spec.rb
-- spec/tests/auxiliary_statement_spec.rb
-- spec/tests/enum_set_spec.rb
+- spec/tests/period_spec.rb
 - spec/tests/coder_spec.rb
 - spec/tests/collector_spec.rb
 - spec/tests/distinct_on_spec.rb
@@ -343,10 +343,11 @@ test_files:
 - spec/tests/lazy_spec.rb
 - spec/tests/quoting_spec.rb
 - spec/tests/relation_spec.rb
-- spec/tests/belongs_to_many_spec.rb
-- spec/tests/period_spec.rb
-- spec/tests/arel_spec.rb
+- spec/tests/auxiliary_statement_spec.rb
+- spec/tests/enum_set_spec.rb
 - spec/tests/has_many_spec.rb
+- spec/tests/belongs_to_many_spec.rb
+- spec/tests/table_inheritance_spec.rb
 - spec/mocks/cache_query.rb
 - spec/mocks/create_table.rb
 - spec/en.yml