where_exists 1.1.5 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 04a754bdba0efe110c9e700feda620618a9f0f35
-  data.tar.gz: 194d5488d6809663b0be8eaba9f26f0ffb224aeb
+SHA256:
+  metadata.gz: 8fe61ef5f7b676e2d9b3704b34f8101e7e84157060f2b11d56db8e99027765a9
+  data.tar.gz: e8de623c18fe2df6c50c809b6bf0b551eb66bf7ae2a36e0ca65cc18a44470b79
 SHA512:
-  metadata.gz: 6a2d63d72377b8f062eee34f2bc228309ebe4201d88b319dda9b9316aa2e84de39d117d21c057f494b2ed2c79f12a2f90aae6ea39a1a168c7e3aeab02b5dfb8a
-  data.tar.gz: 952e052725851bb53f8ade54661ec65d35bdf536836ce589c85bdd29c3cceba7d0dc1347d9bd2aa97d656dc85a01db38f6b0a2d756f535812e06cc63f3a90fea
+  metadata.gz: 9f4b7fe34573309d53e2e81255782a2d4f3dbfa190c9e975d5cc9eb6750f0b118d448401002786862932ed1fcda19cda6ee3387d5a7a036b7594d841872c907e
+  data.tar.gz: 389a33011c215ad3373388d20f5b49f186b80458dc18afee829c9ddf370d84b517e8ad16df300e041198b192f2884f9a4217cd6677179f7999591f5d74580f16

data/lib/where_exists.rb

@@ -61,7 +61,9 @@ module WhereExists
     association_scope = association.scope
 
     if polymorphic
-      associated_models = self.select("DISTINCT #{connection.quote_column_name(association.foreign_type)}").pluck(association.foreign_type).map(&:constantize)
+      associated_models = self.select("DISTINCT #{connection.quote_column_name(association.foreign_type)}").
+        where("#{connection.quote_column_name(association.foreign_type)} IS NOT NULL").pluck(association.foreign_type).
+        uniq.map(&:classify).map(&:constantize)
     else
       associated_models = [association.klass]
     end
@@ -82,8 +84,10 @@ module WhereExists
         query = query.instance_exec(&association_scope)
       end
       if polymorphic
-        other_type = connection.quote(associated_model.name)
-        query = query.where("#{self_type} = #{other_type}")
+        other_types = [associated_model.name, associated_model.table_name]
+        other_types << associated_model.polymorphic_name if associated_model.respond_to?(:polymorphic_name)
+
+        query = query.where("#{self_type} IN (?)", other_types.uniq)
       end
       queries.push query
     end
@@ -129,8 +133,14 @@ module WhereExists
 
     if association.options[:as]
       other_types = quote_table_and_column_name(associated_model.table_name, association.type)
-      self_class = connection.quote(self.name)
-      result = result.where("#{other_types} = #{self_class}")
+      class_values = [self.name, self.table_name]
+      class_values << self.polymorphic_name if associated_model.respond_to?(:polymorphic_name)
+
+      result = result.where("#{other_types} IN (?)", class_values.uniq)
+    end
+
+    if association_scope
+      result = result.instance_exec(&association_scope)
     end
 
     if next_association[:association]
@@ -141,10 +151,6 @@ module WhereExists
       result = result.where(*where_parameters)
     end
 
-    if association_scope
-      result = result.instance_exec(&association_scope)
-    end
-
     [result]
   end
 
@@ -155,11 +161,9 @@ module WhereExists
 
     primary_key = association.options[:primary_key] || self.primary_key
 
-    join_table = [self.table_name, associated_model.table_name].sort.join("_")
-
     self_ids = quote_table_and_column_name(self.table_name, primary_key)
-    join_ids = quote_table_and_column_name(join_table, association.foreign_key)
-    associated_join_ids = quote_table_and_column_name(join_table, "#{associated_model.name.downcase}_id")
+    join_ids = quote_table_and_column_name(association.join_table, association.foreign_key)
+    associated_join_ids = quote_table_and_column_name(association.join_table, association.association_foreign_key)
     associated_ids = quote_table_and_column_name(associated_model.table_name, associated_model.primary_key)
 
     result =
@@ -167,7 +171,7 @@ module WhereExists
       select("1").
       joins(
         <<-SQL
-          INNER JOIN #{connection.quote_table_name(join_table)}
+          INNER JOIN #{connection.quote_table_name(association.join_table)}
           ON #{associated_ids} = #{associated_join_ids}
         SQL
       ).

data/lib/where_exists/version.rb

@@ -1,3 +1,3 @@
 module WhereExists
-  VERSION = "1.1.5"
+  VERSION = "1.2.0"
 end

data/test/belongs_to_polymorphic_test.rb

@@ -60,4 +60,21 @@ class BelongsToPolymorphicTest < Minitest::Test
     assert_equal 1, result.length
     assert_equal orphaned_child.id, result.first.id
   end
+
+  def test_table_name_based_lookup
+    first_entity = FirstPolymorphicEntity.create!
+    second_entity = SecondPolymorphicEntity.create! id: first_entity.id + 1
+
+    first_child = BelongsToPolymorphicChild.create!(polymorphic_entity_id: first_entity.id, polymorphic_entity_type: first_entity.class.table_name)
+    second_child = BelongsToPolymorphicChild.create!(polymorphic_entity_id: second_entity.id, polymorphic_entity_type: second_entity.class.table_name)
+    orphaned_child = BelongsToPolymorphicChild.create!(polymorphic_entity_id: second_entity.id, polymorphic_entity_type: first_entity.class.table_name)
+
+    result = BelongsToPolymorphicChild.where_exists(:polymorphic_entity)
+    assert_equal 2, result.length
+    assert_equal [first_child, second_child].map(&:id).sort, result.map(&:id).sort
+
+    result = BelongsToPolymorphicChild.where_not_exists(:polymorphic_entity)
+    assert_equal 1, result.length
+    assert_equal [orphaned_child].map(&:id).sort, result.map(&:id).sort
+  end
 end

data/test/has_many_polymorphic_test.rb

@@ -35,10 +35,17 @@ class HasManyPolymorphicTest < Minitest::Test
     child = HasManyPolymorphicChild.create!
 
     irrelevant_entity = IrrelevantPolymorphicEntity.create!(children: [child])
-    _relevant_entity = RelevantPolymorphicEntity.create!(id: irrelevant_entity.id)
+    relevant_entity = RelevantPolymorphicEntity.create!(id: irrelevant_entity.id)
+
+    assert_equal 0, RelevantPolymorphicEntity.where_exists(:children).length
+    assert_equal 1, IrrelevantPolymorphicEntity.where_exists(:children).length
+
+    child.update!(polymorphic_thing_type: RelevantPolymorphicEntity.table_name)
 
     result = RelevantPolymorphicEntity.where_exists(:children)
 
-    assert_equal 0, result.length
+    assert_equal 0, IrrelevantPolymorphicEntity.where_exists(:children).length
+    assert_equal 1, result.length
+    assert_equal relevant_entity.id, result.first&.id
   end
 end

data/test/has_many_through_test.rb

@@ -1,34 +1,71 @@
 require_relative 'test_helper'
 
-ActiveRecord::Migration.create_table :projects, :force => true do |t|
+ActiveRecord::Migration.create_table :projects, force: true do |t|
   t.string :name
 end
 
-ActiveRecord::Migration.create_table :tasks, :force => true do |t|
+ActiveRecord::Migration.create_table :tasks, force: true do |t|
   t.string :name
   t.integer :project_id
 end
 
-ActiveRecord::Migration.create_table :line_items, :force => true do |t|
+ActiveRecord::Migration.create_table :line_items, force: true do |t|
   t.string :name
   t.integer :invoice_id
   t.integer :task_id
 end
 
-ActiveRecord::Migration.create_table :work_details, :force => true do |t|
+ActiveRecord::Migration.create_table :work_details, force: true do |t|
   t.string :name
   t.integer :line_item_id
 end
 
-ActiveRecord::Migration.create_table :invoices, :force => true do |t|
+ActiveRecord::Migration.create_table :invoices, force: true do |t|
   t.string :name
 end
 
+ActiveRecord::Migration.create_table :blobs, force: true  do |t|
+end
+
+ActiveRecord::Migration.create_table :attachments, force: true  do |t|
+  t.string     :name,     null: false
+  t.references :record,   null: false, polymorphic: true, index: false
+  t.references :blob,     null: false
+
+  t.datetime :created_at, null: false
+
+  t.index [ :record_type, :record_id, :name, :blob_id ], name: "index_attachments_uniqueness", unique: true
+end
+
+class Attachment < ActiveRecord::Base
+  belongs_to :record, polymorphic: true, touch: true
+  belongs_to :blob
+end
+
+class Blob < ActiveRecord::Base
+  has_many :attachments
+
+  scope :unattached, -> { left_joins(:attachments).where(Attachment.table_name => { blob_id: nil }) }
+
+  before_destroy(prepend: true) do
+    raise ActiveRecord::InvalidForeignKey if attachments.exists?
+  end
+end
+
+
+
 class Project < ActiveRecord::Base
   has_many :tasks
   has_many :invoices, :through => :tasks
   has_many :project_line_items, :through => :tasks, :source => :line_items
   has_many :work_details, :through => :project_line_items
+
+  has_many :attachments, as: :record
+  has_many :blobs, through: :attachments, source: :blob
+  has_many :relevant_attachments, -> { where(name: "relevant") }, as: :record, class_name: "Attachment", inverse_of: :record, dependent: false
+  has_many :relevant_blobs, through: :relevant_attachments, class_name: "Blob", source: :blob
+  has_many :irrelevant_attachments, -> { where(name: "irrelevant") }, as: :record, class_name: "Attachment", inverse_of: :record, dependent: false
+  has_many :irrelevant_blobs, through: :irrelevant_attachments, class_name: "Blob", source: :blob
 end
 
 class Task < ActiveRecord::Base
@@ -36,6 +73,7 @@ class Task < ActiveRecord::Base
 
   has_many :invoices, :through => :line_items
   has_many :line_items
+  has_many :scoped_line_items, -> { where(name: 'relevant') }, class_name: 'LineItem'
 end
 
 class LineItem < ActiveRecord::Base
@@ -94,12 +132,16 @@ class HasManyThroughTest < Minitest::Test
     invoice = Invoice.create!(name: 'relevant')
     irrelevant_invoice = Invoice.create!(name: 'irrelevant')
 
-    line_item = LineItem.create!(task: task, invoice: invoice)
-    irrelevant_line_item = LineItem.create!(task: irrelevant_task, invoice: irrelevant_invoice)
+    line_item = LineItem.create!(name: 'relevant', task: task, invoice: invoice)
+    irrelevant_line_item = LineItem.create!(name: 'relevant', task: irrelevant_task, invoice: irrelevant_invoice)
 
     _work_detail = WorkDetail.create!(line_item: line_item, name: 'relevant')
     _irrelevant_work_detail = WorkDetail.create!(line_item: irrelevant_line_item, name: 'irrelevant')
 
+    blob = Blob.create!()
+    _relevant_attachment = Attachment.create!(name: 'relevant', blob: blob, record: project)
+    _irrelevant_attachment = Attachment.create!(name: 'irrelevant', blob: blob, record: irrelevant_project)
+
     result = Project.where_exists(:invoices, name: 'relevant')
 
     assert_equal 1, result.length
@@ -124,5 +166,28 @@ class HasManyThroughTest < Minitest::Test
 
     assert_equal 1, result.length
     assert_equal irrelevant_project.id, result.first.id
+
+    result = Task.where_exists(:scoped_line_items)
+
+    assert_equal 2, result.length
+
+    result = Project.where_exists(:relevant_blobs)
+
+    assert_equal 1, result.length
+    assert_equal project.id, result.first.id
+
+    result = Project.where_not_exists(:relevant_blobs)
+
+    assert_equal 1, result.length
+    assert_equal irrelevant_project.id, result.first.id
+
+    result = Project.where_exists(:blobs)
+
+    assert_equal 2, result.length
+
+    result = Project.where_not_exists(:blobs)
+
+    assert_equal 0, result.length
+
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: where_exists
 version: !ruby/object:Gem::Version
-  version: 1.1.5
+  version: 1.2.0
 platform: ruby
 authors:
 - Eugene Zolotarev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-15 00:00:00.000000000 Z
+date: 2019-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -125,8 +125,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 3.0.2
 signing_key: 
 specification_version: 4
 summary: "#where_exists extension of ActiveRecord"