sequel-association-filtering 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ff146b722b3e38c2309610aad40275960ac257b8cae86047fb25aa15b1c08e38
-  data.tar.gz: fd4d3faeef0debbcaabebc11418c5d4543ef17e46c709ca4e332d53eceab0790
+  metadata.gz: 6b96fa93edf655b190d3d510e871ab7666218719f0c07e8c5034d47cab3b47c0
+  data.tar.gz: 65f1b9fc8f9ed8d0c9fd499eb5bb32477857bd1c4fb9ad0b1e7185ba44fb0a51
 SHA512:
-  metadata.gz: c13509e8f28653f671101d17c861c4a03ff118c3f44233fb6a522423b5f7698535a56e712bacd4b22a250d82404cad96086caa5138089ac53bdfecd301257122
-  data.tar.gz: 4cc33a23a642c60143869391e8ca678d6cb6b3634695be26e607baa0818b2aa9ac4e6a130c67cb732d72078f0ff59710f55818c92de50509a57c64c9a05b76d6
+  metadata.gz: b0642b74414f320c1152478c25cf34694c152b1f15c96204fc1e17929df7b6671e60fe31f46367cedac198df3a59b7fe11cb117602e7937c4f7bf5d8864a179f
+  data.tar.gz: d70a6cc39248e252a46d7d0c14dd31bbbbd5838531267a0a5d1e8c6b7746b039c4e0e4da440aced09b204c02faba98b6185b6ffbcd8bb2f3d11f67e132ca7894

data/lib/sequel/plugins/association_filtering.rb

@@ -7,30 +7,47 @@ module Sequel
       class Error < StandardError; end
 
       module ClassMethods
-        Plugins.def_dataset_methods(self, :association_filter)
+        Plugins.def_dataset_methods(
+          self,
+          [
+            :association_filter,
+            :association_exclude,
+          ]
+        )
       end
 
       module DatasetMethods
-        def association_filter(association_name)
+        def association_filter(association_name, invert: false)
           reflection =
             model.association_reflections.fetch(association_name) do
               raise Error, "association #{association_name} not found on model #{model}"
             end
 
           if block_given?
-            ds = yield(_association_filter_dataset(reflection))
-            where(ds.exists)
+            cond = yield(_association_filter_dataset(reflection)).exists
+            invert ? exclude(cond) : where(cond)
           else
-            cached_dataset(_association_filter_cache_key(reflection, suffix: :bare)) do
-              where(_association_filter_dataset(reflection).exists)
+            cache_key =
+              _association_filter_cache_key(
+                reflection: reflection,
+                extra: :"bare_#{invert}",
+              )
+
+            cached_dataset(cache_key) do
+              cond = _association_filter_dataset(reflection).exists
+              invert ? exclude(cond) : where(cond)
             end
           end
         end
 
+        def association_exclude(association_name, &block)
+          association_filter(association_name, invert: true, &block)
+        end
+
         private
 
         def _association_filter_dataset(reflection)
-          cache_key = _association_filter_cache_key(reflection)
+          cache_key = _association_filter_cache_key(reflection: reflection)
 
           ds = reflection.associated_dataset
 
@@ -61,8 +78,8 @@ module Sequel
           end
         end
 
-        def _association_filter_cache_key(reflection, suffix: nil)
-          :"_association_filter_#{reflection[:model]}_#{reflection[:name]}_#{suffix}"
+        def _association_filter_cache_key(reflection:, extra: nil)
+          :"_association_filter_#{reflection[:model]}_#{reflection[:name]}_#{extra}"
         end
       end
     end

data/lib/sequel/plugins/association_filtering/version.rb

@@ -1,7 +1,7 @@
 module Sequel
   module Plugins
     module AssociationFiltering
-      VERSION = '0.0.2'
+      VERSION = '0.0.3'
     end
   end
 end

data/spec/many_to_many_spec.rb

@@ -70,4 +70,30 @@ class ManyToManySpec < AssociationFilteringSpecs
       assert_includes record.genres.map(&:id), 5
     end
   end
+
+  describe "association_exclude through a many_to_many_association" do
+    it "should support an empty filter that checks for existence" do
+      expected_count = 100 - DB[:album_genres].distinct(:album_id).count
+
+      ds = Album.association_exclude(:genres)
+      assert_equal %(SELECT * FROM "albums" WHERE NOT (EXISTS (SELECT 1 FROM "genres" INNER JOIN "album_genres" ON ("album_genres"."genre_id" = "genres"."id") WHERE ("album_genres"."album_id" = "albums"."id")))), ds.sql
+      assert_equal expected_count, ds.count
+
+      album_id_to_delete = DB[:album_genres].order_by{random.function}.get(:album_id)
+
+      DB[:album_genres].where(album_id: album_id_to_delete).delete
+      assert_equal expected_count + 1, ds.count
+    end
+
+    it "should support a simple filter" do
+      expected_count = 100 - DB[:album_genres].where(genre_id: 5).distinct(:album_id).count
+
+      ds = Album.association_exclude(:genres){|t| t.where(Sequel[:genres][:id] =~ 5)}
+      assert_equal expected_count, ds.count
+      assert_equal %(SELECT * FROM \"albums\" WHERE NOT (EXISTS (SELECT 1 FROM "genres" INNER JOIN "album_genres" ON ("album_genres"."genre_id" = "genres"."id") WHERE (("album_genres"."album_id" = "albums"."id") AND ("genres"."id" = 5))))), ds.sql
+
+      record = ds.first!
+      refute_includes record.genres.map(&:id), 5
+    end
+  end
 end

data/spec/many_to_one_spec.rb

@@ -45,4 +45,15 @@ class ManyToOneSpec < AssociationFilteringSpecs
       assert_includes [5, 10], record.artist_id
     end
   end
+
+  describe "association_exclude through a many_to_one association" do
+    it "should support a simple filter" do
+      ds = Album.association_exclude(:artist){|a| a.where{mod(id, 5) =~ 0}}
+      assert_equal 80, ds.count
+      assert_equal %(SELECT * FROM "albums" WHERE NOT (EXISTS (SELECT 1 FROM "artists" WHERE (("artists"."id" = "albums"."artist_id") AND (mod("id", 5) = 0)) LIMIT 1))), ds.sql
+
+      record = ds.order_by{random.function}.first
+      refute_includes [5, 10], record.artist_id
+    end
+  end
 end

data/spec/one_to_many_spec.rb

@@ -129,5 +129,26 @@ class OneToManySpec < AssociationFilteringSpecs
         assert_equal 99, ds.count
       end
     end
+
+    describe "association_exclude through a one_to_many association" do
+      it "should support a simple filter" do
+        ds = Artist.association_exclude(:albums){|t| t.where(serial_column: 40)}
+
+        assert_equal 99, ds.count
+        assert_equal %(SELECT * FROM "artists" WHERE NOT (EXISTS (SELECT 1 FROM "albums" WHERE (("albums"."id_1" = "artists"."id_1") AND ("albums"."id_2" = "artists"."id_2") AND ("serial_column" = 40))))), ds.sql
+
+        artists = ds.all
+        refute_includes artists.flat_map(&:albums).map(&:serial_column), 40
+      end
+
+      it "should support an empty filter that checks for existence" do
+        ds = Artist.association_exclude(:albums)
+        assert_equal 0, ds.count
+        assert_equal %(SELECT * FROM "artists" WHERE NOT (EXISTS (SELECT 1 FROM "albums" WHERE (("albums"."id_1" = "artists"."id_1") AND ("albums"."id_2" = "artists"."id_2"))))), ds.sql
+
+        Album.where(id_1: 5, id_2: 6).delete
+        assert_equal 1, ds.count
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel-association-filtering
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Chris Hanks
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-17 00:00:00.000000000 Z
+date: 2018-05-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler