pursuit 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e692c274eaa14b0f1311c56917447a1526285274722fd420fccf3892ac1fcb37
-  data.tar.gz: e7133d0015ea96a8930340e458fb427a2ebf81f4e15c95662b4b9f9a0ed5be81
+  metadata.gz: 4b1d45107d4ab3d9a2ac9d9eaf8451e6f75762f2c8ac71e51683c3afe98009c7
+  data.tar.gz: e40fa3f38548173ba042cd232347127a3059c4e7f4a417569cad81d16b2b3710
 SHA512:
-  metadata.gz: b3b007b9d56efdaa21fc7cb1d7d2d7a8bd9c7988269f614aee7db9cd3e620a92317ede365528aff8f61dcb2fb531c95ded3b29a5a4730fce6b9c3e400ea4c807
-  data.tar.gz: 7340594ab1b4dc75dcc6722304b46b7535591968d5bf65d3f8544a559000162bde3d8d808374e951aa564d8a67e752ef89590b41f23f77e2868b12930d2fa4e6
+  metadata.gz: 65009e855c743fad6e91b5939d59456c845976b2add94fd1d03a9603d34a6046d5e45e58dd3fc7ca33291600f1a17bb879b2c492f1d5c22102bc9f2124c591b3
+  data.tar.gz: 9662bc16e8eb17107089b5bdd7635a91d0647b71a015cff79bf43df4b517729036d8c9ff3fde2b299ca82e63e440b3abca2531eddaa35aeb306472e62a7bc708

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    pursuit (0.4.0)
+    pursuit (0.4.1)
       activerecord (>= 5.2.0, < 7.1.0)
       activesupport (>= 5.2.0, < 7.1.0)
 

data/lib/pursuit/constants.rb

@@ -3,5 +3,5 @@
 module Pursuit
   # @return [String] The gem's semantic version number.
   #
-  VERSION = '0.4.0'
+  VERSION = '0.4.1'
 end

data/lib/pursuit/search.rb

@@ -90,7 +90,7 @@ module Pursuit
 
     def build_arel_for_reflection(reflection, attribute_names, operator, value)
       nodes = build_arel_for_reflection_join(reflection)
-      count_nodes = build_arel_for_relation_count(nodes, operator, value)
+      count_nodes = build_arel_for_relation_count(nodes, operator, value) unless reflection.belongs_to?
       return count_nodes if count_nodes.present?
 
       match_nodes = attribute_names.reduce(nil) do |chain, attribute_name|
@@ -104,6 +104,23 @@ module Pursuit
     end
 
     def build_arel_for_reflection_join(reflection)
+      if reflection.belongs_to?
+        build_arel_for_belongs_to_reflection_join(reflection)
+      else
+        build_arel_for_has_reflection_join(reflection)
+      end
+    end
+
+    def build_arel_for_belongs_to_reflection_join(reflection)
+      reflection_table = reflection.klass.arel_table
+      reflection_table.where(
+        reflection_table[reflection.join_primary_key].eq(
+          options.record_class.arel_table[reflection.join_foreign_key]
+        )
+      )
+    end
+
+    def build_arel_for_has_reflection_join(reflection)
       reflection_table = reflection.klass.arel_table
       reflection_through = reflection.through_reflection
 

data/spec/pursuit/search_spec.rb

@@ -5,6 +5,7 @@ RSpec.describe Pursuit::Search do
 
   let(:search_options) do
     Pursuit::SearchOptions.new(Product) do |o|
+      o.relation :category, :name
       o.relation :variations, :title, :stock_status
 
       o.attribute :title
@@ -16,7 +17,7 @@ RSpec.describe Pursuit::Search do
         ])
       end
 
-      o.attribute :category, :category_id
+      o.attribute :cat, :category_id
     end
   end
 
@@ -253,83 +254,20 @@ RSpec.describe Pursuit::Search do
       end
     end
 
-    context 'when passed a `match` relationship search query' do
-      let(:query) { 'variations*=green' }
-
-      let(:product_a) { Product.create!(title: 'Plain Shirt') }
-      let(:product_b) { Product.create!(title: 'Funky Shirt') }
-
-      let(:product_variation_a) { ProductVariation.create!(product: product_a, title: 'Red') }
-      let(:product_variation_b) { ProductVariation.create!(product: product_b, title: 'Green') }
-      let(:product_variation_c) { ProductVariation.create!(product: product_b, title: 'Blue') }
-
-      before do
-        product_a
-        product_b
-
-        product_variation_a
-        product_variation_b
-        product_variation_c
-      end
-
-      it 'is expected to contain the matching records' do
-        expect(perform).to contain_exactly(product_b)
-      end
-    end
-
-    context 'when passed an `equal to` relationship count query' do
-      let(:query) { 'variations==1' }
-
-      let(:product_a) { Product.create!(title: 'Plain Shirt') }
-      let(:product_b) { Product.create!(title: 'Funky Shirt') }
-      let(:product_c) { Product.create!(title: 'Socks') }
-
-      let(:product_variation_a) { ProductVariation.create!(product: product_b, title: 'Red') }
-      let(:product_variation_b) { ProductVariation.create!(product: product_b, title: 'Green') }
-      let(:product_variation_c) { ProductVariation.create!(product: product_b, title: 'Blue') }
-      let(:product_variation_d) { ProductVariation.create!(product: product_c, title: 'White') }
-
-      before do
-        product_a
-        product_b
-        product_c
-
-        product_variation_a
-        product_variation_b
-        product_variation_c
-        product_variation_d
-      end
-
-      it 'is expected to contain the matching records' do
-        expect(perform).to contain_exactly(product_c)
-      end
-    end
-
-    context 'when passed a `greater than` relationship count query' do
-      let(:query) { 'variations>1' }
+    context 'when querying a custom attribute whose name matches a reflection' do
+      let(:query) { 'cat==shirts' }
 
-      let(:product_a) { Product.create!(title: 'Plain Shirt') }
-      let(:product_b) { Product.create!(title: 'Funky Shirt') }
-      let(:product_c) { Product.create!(title: 'Socks') }
+      let(:shirts_category) { ProductCategory.create!(id: 'shirts', name: 'The Shirt Collection') }
+      let(:socks_category)  { ProductCategory.create!(id: 'socks', name: 'The Sock Collection') }
 
-      let(:product_variation_a) { ProductVariation.create!(product: product_b, title: 'Red') }
-      let(:product_variation_b) { ProductVariation.create!(product: product_b, title: 'Green') }
-      let(:product_variation_c) { ProductVariation.create!(product: product_b, title: 'Blue') }
-      let(:product_variation_d) { ProductVariation.create!(product: product_c, title: 'White') }
-      let(:product_variation_e) { ProductVariation.create!(product: product_a, title: 'Black') }
-      let(:product_variation_f) { ProductVariation.create!(product: product_a, title: 'Gray') }
+      let(:product_a) { Product.create!(title: 'Plain Shirt', category: shirts_category) }
+      let(:product_b) { Product.create!(title: 'Funky Shirt', category: shirts_category) }
+      let(:product_c) { Product.create!(title: 'Socks - Pack of 4', category: socks_category) }
 
       before do
         product_a
         product_b
         product_c
-
-        product_variation_a
-        product_variation_b
-        product_variation_c
-        product_variation_d
-        product_variation_e
-        product_variation_f
       end
 
       it 'is expected to contain the matching records' do
@@ -337,152 +275,243 @@ RSpec.describe Pursuit::Search do
       end
     end
 
-    context 'when passed a `greater than or equal to` relationship count query' do
-      let(:query) { 'variations>=2' }
-
-      let(:product_a) { Product.create!(title: 'Plain Shirt') }
-      let(:product_b) { Product.create!(title: 'Funky Shirt') }
-      let(:product_c) { Product.create!(title: 'Socks') }
-
-      let(:product_variation_a) { ProductVariation.create!(product: product_b, title: 'Red') }
-      let(:product_variation_b) { ProductVariation.create!(product: product_b, title: 'Green') }
-      let(:product_variation_c) { ProductVariation.create!(product: product_b, title: 'Blue') }
-      let(:product_variation_d) { ProductVariation.create!(product: product_c, title: 'White') }
-      let(:product_variation_e) { ProductVariation.create!(product: product_a, title: 'Black') }
-      let(:product_variation_f) { ProductVariation.create!(product: product_a, title: 'Gray') }
+    context 'when searching a #has_many relationship' do
+      context 'when passed a `match` relationship search query' do
+        let(:query) { 'variations*=green' }
 
-      before do
-        product_a
-        product_b
-        product_c
+        let(:product_a) { Product.create!(title: 'Plain Shirt') }
+        let(:product_b) { Product.create!(title: 'Funky Shirt') }
+
+        let(:product_variation_a) { ProductVariation.create!(product: product_a, title: 'Red') }
+        let(:product_variation_b) { ProductVariation.create!(product: product_b, title: 'Green') }
+        let(:product_variation_c) { ProductVariation.create!(product: product_b, title: 'Blue') }
+
+        before do
+          product_a
+          product_b
+
+          product_variation_a
+          product_variation_b
+          product_variation_c
+        end
 
-        product_variation_a
-        product_variation_b
-        product_variation_c
-        product_variation_d
-        product_variation_e
-        product_variation_f
+        it 'is expected to contain the matching records' do
+          expect(perform).to contain_exactly(product_b)
+        end
       end
 
-      it 'is expected to contain the matching records' do
-        expect(perform).to contain_exactly(product_a, product_b)
+      context 'when passed an `equal to` relationship count query' do
+        let(:query) { 'variations==1' }
+
+        let(:product_a) { Product.create!(title: 'Plain Shirt') }
+        let(:product_b) { Product.create!(title: 'Funky Shirt') }
+        let(:product_c) { Product.create!(title: 'Socks') }
+
+        let(:product_variation_a) { ProductVariation.create!(product: product_b, title: 'Red') }
+        let(:product_variation_b) { ProductVariation.create!(product: product_b, title: 'Green') }
+        let(:product_variation_c) { ProductVariation.create!(product: product_b, title: 'Blue') }
+        let(:product_variation_d) { ProductVariation.create!(product: product_c, title: 'White') }
+
+        before do
+          product_a
+          product_b
+          product_c
+
+          product_variation_a
+          product_variation_b
+          product_variation_c
+          product_variation_d
+        end
+
+        it 'is expected to contain the matching records' do
+          expect(perform).to contain_exactly(product_c)
+        end
+      end
+
+      context 'when passed a `greater than` relationship count query' do
+        let(:query) { 'variations>1' }
+
+        let(:product_a) { Product.create!(title: 'Plain Shirt') }
+        let(:product_b) { Product.create!(title: 'Funky Shirt') }
+        let(:product_c) { Product.create!(title: 'Socks') }
+
+        let(:product_variation_a) { ProductVariation.create!(product: product_b, title: 'Red') }
+        let(:product_variation_b) { ProductVariation.create!(product: product_b, title: 'Green') }
+        let(:product_variation_c) { ProductVariation.create!(product: product_b, title: 'Blue') }
+        let(:product_variation_d) { ProductVariation.create!(product: product_c, title: 'White') }
+        let(:product_variation_e) { ProductVariation.create!(product: product_a, title: 'Black') }
+        let(:product_variation_f) { ProductVariation.create!(product: product_a, title: 'Gray') }
+
+        before do
+          product_a
+          product_b
+          product_c
+
+          product_variation_a
+          product_variation_b
+          product_variation_c
+          product_variation_d
+          product_variation_e
+          product_variation_f
+        end
+
+        it 'is expected to contain the matching records' do
+          expect(perform).to contain_exactly(product_a, product_b)
+        end
+      end
+
+      context 'when passed a `greater than or equal to` relationship count query' do
+        let(:query) { 'variations>=2' }
+
+        let(:product_a) { Product.create!(title: 'Plain Shirt') }
+        let(:product_b) { Product.create!(title: 'Funky Shirt') }
+        let(:product_c) { Product.create!(title: 'Socks') }
+
+        let(:product_variation_a) { ProductVariation.create!(product: product_b, title: 'Red') }
+        let(:product_variation_b) { ProductVariation.create!(product: product_b, title: 'Green') }
+        let(:product_variation_c) { ProductVariation.create!(product: product_b, title: 'Blue') }
+        let(:product_variation_d) { ProductVariation.create!(product: product_c, title: 'White') }
+        let(:product_variation_e) { ProductVariation.create!(product: product_a, title: 'Black') }
+        let(:product_variation_f) { ProductVariation.create!(product: product_a, title: 'Gray') }
+
+        before do
+          product_a
+          product_b
+          product_c
+
+          product_variation_a
+          product_variation_b
+          product_variation_c
+          product_variation_d
+          product_variation_e
+          product_variation_f
+        end
+
+        it 'is expected to contain the matching records' do
+          expect(perform).to contain_exactly(product_a, product_b)
+        end
+      end
+
+      context 'when passed a `less than` relationship count query' do
+        let(:query) { 'variations<3' }
+
+        let(:product_a) { Product.create!(title: 'Plain Shirt') }
+        let(:product_b) { Product.create!(title: 'Funky Shirt') }
+        let(:product_c) { Product.create!(title: 'Socks') }
+
+        let(:product_variation_a) { ProductVariation.create!(product: product_b, title: 'Red') }
+        let(:product_variation_b) { ProductVariation.create!(product: product_b, title: 'Green') }
+        let(:product_variation_c) { ProductVariation.create!(product: product_b, title: 'Blue') }
+        let(:product_variation_d) { ProductVariation.create!(product: product_c, title: 'White') }
+        let(:product_variation_e) { ProductVariation.create!(product: product_a, title: 'Black') }
+        let(:product_variation_f) { ProductVariation.create!(product: product_a, title: 'Gray') }
+
+        before do
+          product_a
+          product_b
+          product_c
+
+          product_variation_a
+          product_variation_b
+          product_variation_c
+          product_variation_d
+          product_variation_e
+          product_variation_f
+        end
+
+        it 'is expected to contain the matching records' do
+          expect(perform).to contain_exactly(product_a, product_c)
+        end
+      end
+
+      context 'when passed a `less than or equal to` relationship count query' do
+        let(:query) { 'variations<=2' }
+
+        let(:product_a) { Product.create!(title: 'Plain Shirt') }
+        let(:product_b) { Product.create!(title: 'Funky Shirt') }
+        let(:product_c) { Product.create!(title: 'Socks') }
+
+        let(:product_variation_a) { ProductVariation.create!(product: product_b, title: 'Red') }
+        let(:product_variation_b) { ProductVariation.create!(product: product_b, title: 'Green') }
+        let(:product_variation_c) { ProductVariation.create!(product: product_b, title: 'Blue') }
+        let(:product_variation_d) { ProductVariation.create!(product: product_c, title: 'White') }
+        let(:product_variation_e) { ProductVariation.create!(product: product_a, title: 'Black') }
+        let(:product_variation_f) { ProductVariation.create!(product: product_a, title: 'Gray') }
+
+        before do
+          product_a
+          product_b
+          product_c
+
+          product_variation_a
+          product_variation_b
+          product_variation_c
+          product_variation_d
+          product_variation_e
+          product_variation_f
+        end
+
+        it 'is expected to contain the matching records' do
+          expect(perform).to contain_exactly(product_a, product_c)
+        end
+      end
+
+      context 'when passed a `greater than` and `less than` relationship count query' do
+        let(:query) { 'variations>1 variations<3' }
+
+        let(:product_a) { Product.create!(title: 'Plain Shirt') }
+        let(:product_b) { Product.create!(title: 'Funky Shirt') }
+        let(:product_c) { Product.create!(title: 'Socks') }
+
+        let(:product_variation_a) { ProductVariation.create!(product: product_b, title: 'Red') }
+        let(:product_variation_b) { ProductVariation.create!(product: product_b, title: 'Green') }
+        let(:product_variation_c) { ProductVariation.create!(product: product_b, title: 'Blue') }
+        let(:product_variation_d) { ProductVariation.create!(product: product_c, title: 'White') }
+        let(:product_variation_e) { ProductVariation.create!(product: product_a, title: 'Black') }
+        let(:product_variation_f) { ProductVariation.create!(product: product_a, title: 'Gray') }
+
+        before do
+          product_a
+          product_b
+          product_c
+
+          product_variation_a
+          product_variation_b
+          product_variation_c
+          product_variation_d
+          product_variation_e
+          product_variation_f
+        end
+
+        it 'is expected to contain the matching records' do
+          expect(perform).to contain_exactly(product_a)
+        end
       end
     end
 
-    context 'when passed a `less than` relationship count query' do
-      let(:query) { 'variations<3' }
+    context 'when searching a #belongs_to relationship' do
+      context 'when passed a `match` relationship search query' do
+        let(:query) { 'category*=shirt' }
 
-      let(:product_a) { Product.create!(title: 'Plain Shirt') }
-      let(:product_b) { Product.create!(title: 'Funky Shirt') }
-      let(:product_c) { Product.create!(title: 'Socks') }
+        let(:product_category_a) { ProductCategory.create!(id: 'one', name: 'Shirts') }
+        let(:product_category_b) { ProductCategory.create!(id: 'two', name: 'Socks') }
 
-      let(:product_variation_a) { ProductVariation.create!(product: product_b, title: 'Red') }
-      let(:product_variation_b) { ProductVariation.create!(product: product_b, title: 'Green') }
-      let(:product_variation_c) { ProductVariation.create!(product: product_b, title: 'Blue') }
-      let(:product_variation_d) { ProductVariation.create!(product: product_c, title: 'White') }
-      let(:product_variation_e) { ProductVariation.create!(product: product_a, title: 'Black') }
-      let(:product_variation_f) { ProductVariation.create!(product: product_a, title: 'Gray') }
+        let(:product_a) { Product.create!(category: product_category_a, title: 'Plain Shirt') }
+        let(:product_b) { Product.create!(category: product_category_a, title: 'Funky Shirt') }
+        let(:product_c) { Product.create!(category: product_category_b, title: 'White Socks') }
 
-      before do
-        product_a
-        product_b
-        product_c
-
-        product_variation_a
-        product_variation_b
-        product_variation_c
-        product_variation_d
-        product_variation_e
-        product_variation_f
-      end
-
-      it 'is expected to contain the matching records' do
-        expect(perform).to contain_exactly(product_a, product_c)
-      end
-    end
-
-    context 'when passed a `less than or equal to` relationship count query' do
-      let(:query) { 'variations<=2' }
-
-      let(:product_a) { Product.create!(title: 'Plain Shirt') }
-      let(:product_b) { Product.create!(title: 'Funky Shirt') }
-      let(:product_c) { Product.create!(title: 'Socks') }
-
-      let(:product_variation_a) { ProductVariation.create!(product: product_b, title: 'Red') }
-      let(:product_variation_b) { ProductVariation.create!(product: product_b, title: 'Green') }
-      let(:product_variation_c) { ProductVariation.create!(product: product_b, title: 'Blue') }
-      let(:product_variation_d) { ProductVariation.create!(product: product_c, title: 'White') }
-      let(:product_variation_e) { ProductVariation.create!(product: product_a, title: 'Black') }
-      let(:product_variation_f) { ProductVariation.create!(product: product_a, title: 'Gray') }
-
-      before do
-        product_a
-        product_b
-        product_c
+        before do
+          product_category_a
+          product_category_b
 
-        product_variation_a
-        product_variation_b
-        product_variation_c
-        product_variation_d
-        product_variation_e
-        product_variation_f
-      end
-
-      it 'is expected to contain the matching records' do
-        expect(perform).to contain_exactly(product_a, product_c)
-      end
-    end
-
-    context 'when passed a `greater than` and `less than` relationship count query' do
-      let(:query) { 'variations>1 variations<3' }
-
-      let(:product_a) { Product.create!(title: 'Plain Shirt') }
-      let(:product_b) { Product.create!(title: 'Funky Shirt') }
-      let(:product_c) { Product.create!(title: 'Socks') }
+          product_a
+          product_b
+          product_c
+        end
 
-      let(:product_variation_a) { ProductVariation.create!(product: product_b, title: 'Red') }
-      let(:product_variation_b) { ProductVariation.create!(product: product_b, title: 'Green') }
-      let(:product_variation_c) { ProductVariation.create!(product: product_b, title: 'Blue') }
-      let(:product_variation_d) { ProductVariation.create!(product: product_c, title: 'White') }
-      let(:product_variation_e) { ProductVariation.create!(product: product_a, title: 'Black') }
-      let(:product_variation_f) { ProductVariation.create!(product: product_a, title: 'Gray') }
-
-      before do
-        product_a
-        product_b
-        product_c
-
-        product_variation_a
-        product_variation_b
-        product_variation_c
-        product_variation_d
-        product_variation_e
-        product_variation_f
-      end
-
-      it 'is expected to contain the matching records' do
-        expect(perform).to contain_exactly(product_a)
-      end
-    end
-
-    context 'when querying a custom attribute whose name matches a reflection' do
-      let(:query) { 'category==shirts' }
-
-      let(:shirts_category) { ProductCategory.create!(id: 'shirts', name: 'The Shirt Collection') }
-      let(:socks_category)  { ProductCategory.create!(id: 'socks', name: 'The Sock Collection') }
-
-      let(:product_a) { Product.create!(title: 'Plain Shirt', category: shirts_category) }
-      let(:product_b) { Product.create!(title: 'Funky Shirt', category: shirts_category) }
-      let(:product_c) { Product.create!(title: 'Socks - Pack of 4', category: socks_category) }
-
-      before do
-        product_a
-        product_b
-        product_c
-      end
-
-      it 'is expected to contain the matching records' do
-        expect(perform).to contain_exactly(product_a, product_b)
+        it 'is expected to contain the matching records' do
+          expect(perform).to contain_exactly(product_a, product_b)
+        end
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pursuit
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Nialto Services
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-21 00:00:00.000000000 Z
+date: 2022-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord