torque-postgresql 2.0.4 → 2.1.2

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

@@ -9,7 +9,7 @@ module Torque
       module Builder
         def self.include_on(klass, method_name, builder_klass, **extra, &block)
           klass.define_singleton_method(method_name) do |*args, **options|
-            return unless connection.table_exists?(table_name)
+            return unless table_exists?
 
             args.each do |attribute|
               begin

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

@@ -33,13 +33,13 @@ module Torque
           def values_methods
             return @values_methods if defined?(@values_methods)
 
-            prefix = options.fetch(:prefix, nil).try(:<<, '_')
-            suffix = options.fetch(:suffix, nil).try(:prepend, '_')
+            prefix = options.fetch(:prefix, nil)
+            suffix = options.fetch(:suffix, nil)
 
-            prefix = attribute + '_' if prefix == true
-            suffix = '_' + attribute if suffix == true
+            prefix = attribute if prefix == true
+            suffix = attribute if suffix == true
 
-            base   = "#{prefix}%s#{suffix}"
+            base   = [prefix, '%s', suffix].compact.join('_')
 
             @values_methods = begin
               values.map do |val|

data/lib/torque/postgresql/attributes/enum.rb

@@ -29,7 +29,7 @@ module Torque
           def include_on(klass, method_name = nil)
             method_name ||= Torque::PostgreSQL.config.enum.base_method
             Builder.include_on(klass, method_name, Builder::Enum) do |builder|
-              defined_enums[builder.attribute.to_sym] = builder.subtype
+              defined_enums[builder.attribute.to_s] = builder.subtype.klass
             end
           end
 

data/lib/torque/postgresql/attributes/enum_set.rb

@@ -32,7 +32,7 @@ module Torque
           def include_on(klass, method_name = nil)
             method_name ||= Torque::PostgreSQL.config.enum.set_method
             Builder.include_on(klass, method_name, Builder::Enum, set_features: true) do |builder|
-              defined_enums[builder.attribute.to_sym] = builder.subtype
+              defined_enums[builder.attribute.to_s] = builder.subtype
             end
           end
 

data/lib/torque/postgresql/autosave_association.rb

@@ -4,38 +4,35 @@ 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) { save_belongs_to_many_array(reflection) }
-
-          if PostgreSQL::AR610
-            around_save(:around_save_collection_association)
-          else
-            before_save(:before_save_collection_association)
-            after_save(:after_save_collection_association) if ::ActiveRecord::Base
-              .instance_methods.include?(:after_save_collection_association)
+          define_non_cyclic_method(save_method) do
+            save_belongs_to_many_association(reflection)
           end
 
-          before_create(save_method)
-          before_update(save_method)
+          before_save(save_method)
 
           define_autosave_validation_callbacks(reflection)
         end
       end
 
-      def save_belongs_to_many_array(reflection)
-        save_collection_association(reflection)
+      # 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)
-        return unless association
-
-        klass_attr = reflection.active_record_primary_key
-        source_attr = reflection.foreign_key
-
-        records = association.target.each_with_object(klass_attr)
-        write_attribute(source_attr, records.map(&:read_attribute).compact)
+        association&.build_changes { save_collection_association(reflection) }
+      rescue ::ActiveRecord::RecordInvalid
+        throw(:abort)
+      ensure
+        @new_record_before_save = previously_new_record_before_save
       end
     end
 

data/lib/torque/postgresql/base.rb

@@ -200,11 +200,18 @@ 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
 
+        # Allow extra keyword arguments to be sent to +InsertAll+
+        def upsert_all(attributes, **xargs)
+          xargs = xargs.merge(on_duplicate: :update)
+          ::ActiveRecord::InsertAll.new(self, attributes, **xargs).execute
+        end
+
         protected
 
           # Allow optional select attributes to be loaded manually when they are

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/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.4'
+    VERSION = '2.1.2'
   end
 end

data/spec/factories/item.rb

@@ -0,0 +1,5 @@
+FactoryBot.define do
+  factory :item do
+    name { Faker::Lorem.sentence }
+  end
+end

data/spec/models/item.rb

@@ -0,0 +1,3 @@
+class Item < ActiveRecord::Base
+  belongs_to_many :tags
+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 = 70
 
   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
@@ -101,6 +102,13 @@ begin
       t.index ["author_id"], name: "index_posts_on_author_id", using: :btree
     end
 
+    create_table "items", force: :cascade do |t|
+      t.string   "name"
+      t.bigint   "tag_ids", array: true, default: "{1}"
+      t.datetime "created_at", null: false
+      t.datetime "updated_at", null: false
+    end
+
     create_table "users", force: :cascade do |t|
       t.string   "name",       null: false
       t.enum     "role",                    subtype: :roles, default: :visitor

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,80 @@ 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 'does not trigger after commit on the associated record' do
+      called = false
+
+      tag = FactoryBot.create(:tag)
+      Tag.after_commit { called = true }
+
+      expect(called).to be_falsey
+
+      subject.tags << tag
+
+      expect(subject.tag_ids).to be_eql([tag.id])
+      expect(called).to be_falsey
+
+      Tag.reset_callbacks(:commit)
+    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 +191,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 +202,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 +241,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 +281,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 +297,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 +314,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 +345,33 @@ 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
+      subject { FactoryBot.create(:item) }
+
+      it 'will always return the column default value' do
+        expect(subject.tag_ids).to be_a(Array)
+        expect(subject.tag_ids).to be_eql([1])
+      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_eql([1, *records.map(&:id)])
+
+        subject.tags.clear
+        subject.reload
+        expect(subject.tag_ids).to be_a(Array)
+        expect(subject.tag_ids).to be_eql([1])
+      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)