scoped_search 4.1.8 → 4.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 76592b4cfe81be4cef968ea35cd9659957af349738fb799ce5e34608247b320a
-  data.tar.gz: 43e889676986012a6827d6904c616e66e73eecd7a4381ed4e4eb573da270f3f1
+  metadata.gz: 9c1453ebb8fe2391f71ea35171f2115ed89bb7920a1a042d86a4393fe218888c
+  data.tar.gz: 61d2d0e948a952f7e955240747dae7e529103c5871ad3160cb2213574f0f155a
 SHA512:
-  metadata.gz: 6d0d6000ce3a827d33c24591548fcbc6c477c0a9d878dfa39c4a92c5eaaa9bdfe619a5df6c410b2469ebfff4c88a41aef7669afeb591e5d5d6e9a47704bf873c
-  data.tar.gz: d9a20afd3c5328f2195b694a3c305a4f00e4a104680fcf8292afb2b1e7cd838da86ce07c03648312d670d010ec7cda38684bc5be24e9841ffbc445dfc5e9e6d8
+  metadata.gz: 04e61c564c6117d60b6f82b970df5c6c7a68362d828d89d1cf5d2bf7f6b7c9ea777cf641dbb2a21be895905305c0c7305105c9840d391aa702cd69eab706fd4d
+  data.tar.gz: 842c31b1714558d8bd4578d47b87bca4fa4298617a16168b66a77e6ff06ee1f43406b30be3557a9c50222ba5effaa9c5eec27832839e75bb11faf085f95bb7bc

data/.travis.yml

@@ -21,6 +21,7 @@ rvm:
 - "2.4.0"
 - "2.5.1"
 - "2.6.0"
+- "2.7.1"
 - ruby-head
 - jruby-19mode
 - jruby-head
@@ -76,3 +77,13 @@ matrix:
       gemfile: Gemfile.activerecord60_with_activesupport60
     - rvm: "2.4.0"
       gemfile: Gemfile.activerecord60_with_activesupport60
+    - rvm: "2.7.1"
+      gemfile: Gemfile.activerecord42
+    - rvm: "2.7.1"
+      gemfile: Gemfile.activerecord50
+    - rvm: "2.7.1"
+      gemfile: Gemfile.activerecord51
+    - rvm: "2.7.1"
+      gemfile: Gemfile.activerecord52
+    - rvm: "2.7.1"
+      gemfile: Gemfile.activerecord52_with_activesupport52

data/lib/scoped_search/query_builder.rb

@@ -229,11 +229,13 @@ module ScopedSearch
 
       if field.relation && definition.reflection_by_name(field.definition.klass, field.relation).macro == :has_many
         connection = field.definition.klass.connection
-        primary_key = "#{connection.quote_table_name(field.definition.klass.table_name)}.#{connection.quote_column_name(field.definition.klass.primary_key)}"
-        key, join_table = if definition.reflection_by_name(field.definition.klass, field.relation).options.has_key?(:through)
+        reflection = definition.reflection_by_name(field.definition.klass, field.relation)
+        primary_key_col = reflection.options[:primary_key] || field.definition.klass.primary_key
+        primary_key = "#{connection.quote_table_name(field.definition.klass.table_name)}.#{connection.quote_column_name(primary_key_col)}"
+        key, join_table = if reflection.options.has_key?(:through)
                             [primary_key, has_many_through_join(field)]
                           else
-                            [connection.quote_column_name(field.reflection_keys(definition.reflection_by_name(field.definition.klass, field.relation))[1]),
+                            [connection.quote_column_name(field.reflection_keys(reflection)[1]),
                              connection.quote_table_name(field.klass.table_name)]
                           end
 
@@ -269,46 +271,46 @@ module ScopedSearch
       middle_table_association
     end
 
+    # Walk the chain of has-many-throughs, collecting all tables we will need to join
+    def nested_has_many(many_class, relation)
+      acc = [relation]
+      while (reflection = definition.reflection_by_name(many_class, relation))
+        break if reflection.nil? || reflection.options[:through].nil?
+        relation = reflection.options[:through]
+        acc.unshift(relation)
+      end
+      acc.map { |relation| definition.reflection_by_name(many_class, relation) }
+    end
+
     def has_many_through_join(field)
       many_class = field.definition.klass
-      through = definition.reflection_by_name(many_class, field.relation).options[:through]
-      through_class = definition.reflection_by_name(many_class, through).klass
-
       connection = many_class.connection
-
-      # table names
-      endpoint_table_name = field.klass.table_name
-      many_table_name = many_class.table_name
-      middle_table_name = through_class.table_name
-
-      # primary and foreign keys + optional conditions for the joins
-      pk1, fk1   = field.reflection_keys(definition.reflection_by_name(many_class, through))
-      condition_many_to_middle = if with_polymorphism?(many_class, field.klass, through, through_class)
-                                   field.reflection_conditions(definition.reflection_by_name(field.klass, many_table_name))
-                                 else
-                                   ''
-                                 end
-      condition_middle_to_end = field.reflection_conditions(definition.reflection_by_name(field.klass, middle_table_name))
-
-      # primary and foreign keys + optional condition for the endpoint to middle join
-      middle_table_association = find_has_many_through_association(field, through) || middle_table_name
-      pk2, fk2   = field.reflection_keys(definition.reflection_by_name(field.klass, middle_table_association))
-      condition2 = field.reflection_conditions(definition.reflection_by_name(many_class, field.relation))
-
-      <<-SQL
-        #{connection.quote_table_name(many_table_name)}
-        INNER JOIN #{connection.quote_table_name(middle_table_name)}
-        ON #{connection.quote_table_name(many_table_name)}.#{connection.quote_column_name(pk1)} = #{connection.quote_table_name(middle_table_name)}.#{connection.quote_column_name(fk1)} #{condition_many_to_middle} #{condition_middle_to_end}
-        INNER JOIN #{connection.quote_table_name(endpoint_table_name)}
-        ON #{connection.quote_table_name(middle_table_name)}.#{connection.quote_column_name(fk2)} = #{connection.quote_table_name(endpoint_table_name)}.#{connection.quote_column_name(pk2)} #{condition2}
-      SQL
+      sql = connection.quote_table_name(many_class.table_name)
+      join_reflections = nested_has_many(many_class, field.relation)
+      table_names = [many_class.table_name] + join_reflections.map(&:table_name)
+
+      join_reflections.zip(table_names.zip(join_reflections.drop(1))).reduce(sql) do |acc, (reflection, (previous_table, next_reflection))|
+        klass = reflection.method(:join_keys).arity == 1 ? [reflection.klass] : [] # ActiveRecord <5.2 workaround
+        fk1, pk1 = reflection.join_keys(*klass).values # We are joining the tables "in reverse", so the PK and FK are swapped
+
+        # primary and foreign keys + optional conditions for the joins
+        join_condition = if with_polymorphism?(reflection)
+                           field.reflection_conditions(definition.reflection_by_name(next_reflection.klass, previous_table))
+                         else
+                           ''
+                         end
+
+        acc + <<-SQL
+          INNER JOIN #{connection.quote_table_name(reflection.table_name)}
+          ON #{connection.quote_table_name(previous_table)}.#{connection.quote_column_name(pk1)} = #{connection.quote_table_name(reflection.table_name)}.#{connection.quote_column_name(fk1)} #{join_condition}
+        SQL
+      end
     end
 
-    def with_polymorphism?(many_class, endpoint_class, through, through_class)
-      reflections = [definition.reflection_by_name(endpoint_class, through), definition.reflection_by_name(many_class, through)].compact
-      as = reflections.map(&:options).compact.map { |opt| opt[:as] }.compact
-      return false if as.empty?
-      definition.reflection_by_name(through_class, as.first).options[:polymorphic]
+    def with_polymorphism?(reflection)
+      as = reflection.options[:as]
+      return unless as
+      definition.reflection_by_name(reflection.klass, as).options[:polymorphic]
     end
 
     # This module gets included into the Field class to add SQL generation.

data/lib/scoped_search/version.rb

@@ -1,3 +1,3 @@
 module ScopedSearch
-  VERSION = "4.1.8"
+  VERSION = "4.1.9"
 end

data/spec/integration/nested_has_many_through_querying_spec.rb

@@ -0,0 +1,100 @@
+require "spec_helper"
+
+# These specs will run on all databases that are defined in the spec/database.yml file.
+# Comment out any databases that you do not have available for testing purposes if needed.
+ScopedSearch::RSpec::Database.test_databases.each do |db|
+
+  describe ScopedSearch, "using a #{db} database" do
+
+    before(:all) do
+      ScopedSearch::RSpec::Database.establish_named_connection(db)
+    end
+
+    after(:all) do
+      ScopedSearch::RSpec::Database.close_connection
+    end
+
+    context 'quering on associations which are behind multiple has-many-through associations' do
+
+      before(:all) do
+        ActiveRecord::Migration.create_table(:sources) { |t| t.string :name }
+        ActiveRecord::Migration.create_table(:first_jumps) { |t| t.string :name; t.integer :source_id }
+        ActiveRecord::Migration.create_table(:join_jumps) { |t| t.string :name; t.integer :first_jump_id; t.integer :destination_id }
+        ActiveRecord::Migration.create_table(:destinations) { |t| t.string :name; }
+
+        class Source < ActiveRecord::Base
+          has_many :first_jumps
+          has_many :join_jumps, :through => :first_jumps
+          has_many :destinations, :through => :join_jumps
+
+          scoped_search :relation => :first_jumps, :on => :name, :rename => 'first_jump.name'
+          scoped_search :relation => :join_jumps, :on => :name, :rename => 'join_jump.name'
+          scoped_search :relation => :destinations, :on => :name, :rename => 'destination.name'
+        end
+
+        class FirstJump < ActiveRecord::Base
+          belongs_to :source
+          has_many :join_jumps
+          has_many :destinations, :through => :join_jumps
+        end
+
+        class JoinJump < ActiveRecord::Base
+          has_one :source, :through => :first_jump
+          belongs_to :first_jump
+          belongs_to :destination
+        end
+
+        class Destination < ActiveRecord::Base
+          has_many :join_jumps
+          has_many :first_jumps, :through => :join_jumps
+          has_many :sources, :through => :first_jumps
+        end
+
+        @destination1 = Destination.create!(:name => 'dest-1')
+        @destination2 = Destination.create!(:name => 'dest-2')
+        @destination3 = Destination.create!(:name => 'dest-3')
+        @source1 = Source.create!(:name => 'src1')
+        @first_jump1 = FirstJump.create!(:name => 'jump-1-1', :source => @source1)
+        @first_jump2 = FirstJump.create!(:name => 'jump-1-2', :source => @source1)
+
+        @source2 = Source.create!(:name => 'src2')
+        @first_jump_2_1 = FirstJump.create!(:name => 'jump-2-1', :source => @source2)
+        @first_jump_2_2 = FirstJump.create!(:name => 'jump-2-2', :source => @source2)
+        @first_jump_2_3 = FirstJump.create!(:name => 'jump-2-3', :source => @source2)
+        @first_jump_2_4 = FirstJump.create!(:name => 'jump-2-4', :source => @source2)
+
+        JoinJump.create!(:name => 'join-1-1', :destination => @destination1, :first_jump => @first_jump1)
+        JoinJump.create!(:name => 'join-1-2', :destination => @destination2, :first_jump => @first_jump2)
+
+        JoinJump.create!(:name => 'join-2-1', :destination => @destination1, :first_jump => @first_jump_2_1)
+        JoinJump.create!(:name => 'join-2-2', :destination => @destination2, :first_jump => @first_jump_2_2)
+        JoinJump.create!(:name => 'join-2-3', :destination => @destination2, :first_jump => @first_jump_2_3)
+        JoinJump.create!(:name => 'join-2-4', :destination => @destination3, :first_jump => @first_jump_2_4)
+      end
+
+      after(:all) do
+        ScopedSearch::RSpec::Database.drop_model(Source)
+        ScopedSearch::RSpec::Database.drop_model(FirstJump)
+        ScopedSearch::RSpec::Database.drop_model(JoinJump)
+        ScopedSearch::RSpec::Database.drop_model(Destination)
+        Object.send :remove_const, :Source
+        Object.send :remove_const, :FirstJump
+        Object.send :remove_const, :JoinJump
+        Object.send :remove_const, :Destination
+      end
+
+      it "allows searching on has many through has many" do
+        Source.search_for("join_jump.name = join-1-1").should == [@source1]
+        Source.search_for("join_jump.name = join-2-1").should == [@source2]
+        Source.search_for("join_jump.name ^ (join-1-1, join-2-1)").order(:id).should == [@source1, @source2]
+      end
+
+      it "allows searching on has many through has one through has many" do
+        Source.search_for("destination.name = dest-1").order(:id).should == [@source1, @source2]
+        Source.search_for("destination.name = dest-3").order(:id).should == [@source2]
+        Source.search_for("destination.name = dest-3 or destination.name = dest-2").order(:id).should == [@source1, @source2]
+        Source.search_for("destination.name = dest-3 and destination.name = dest-2").should == [@source2]
+      end
+    end
+  end
+end

data/spec/integration/relation_querying_spec.rb

@@ -351,9 +351,10 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
 
         # Create some tables
         ActiveRecord::Migration.create_table(:taggables) { |t| t.integer :taggable_id; t.string :taggable_type; t.integer :tag_id }
-        ActiveRecord::Migration.create_table(:dogs) { |t| t.string :related }
+        ActiveRecord::Migration.create_table(:dogs) { |t| t.string :related; t.integer :owner_id }
         ActiveRecord::Migration.create_table(:cats) { |t| t.string :related }
         ActiveRecord::Migration.create_table(:tags) { |t| t.string :foo }
+        ActiveRecord::Migration.create_table(:owners) { |t| t.string :name }
 
         # The related classes
         class Taggable < ActiveRecord::Base; belongs_to :tag; belongs_to :taggable, :polymorphic => true; end
@@ -369,6 +370,7 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
         class Dog < ActiveRecord::Base
           has_many :taggables, :as => :taggable
           has_many :tags, :through => :taggables
+          belongs_to :owner
 
           scoped_search :relation => :tags, :on => :foo
         end
@@ -378,6 +380,14 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
           has_many :tags, :through => :taggables
         end
 
+        class Owner < ActiveRecord::Base
+          has_many :dogs
+          has_many :taggables, :as => :taggable, :through => :dogs
+          has_many :tags, :through => :taggables
+
+          scoped_search :relation => :tags, :on => :foo
+        end
+
         @tag_1 = Tag.create!(:foo => 'foo')
         @tag_2 = Tag.create!(:foo => 'foo too')
         @tag_3 = Tag.create!(:foo => 'foo three')
@@ -386,6 +396,8 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
         @dog_2 = Dog.create(:related => 'baz too!')
         @cat_1 = Cat.create(:related => 'mitzi')
 
+        @owner_1 = Owner.create(:name => 'Fred', :dogs => [@dog_1])
+
         Taggable.create!(:tag => @tag_1, :taggable => @dog_1, :taggable_type => 'Dog' )
         Taggable.create!(:tag => @tag_1)
         Taggable.create!(:tag => @tag_2, :taggable => @dog_1 , :taggable_type => 'Dog')
@@ -400,12 +412,18 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
         ActiveRecord::Migration.drop_table(:taggables)
         ActiveRecord::Migration.drop_table(:tags)
         ActiveRecord::Migration.drop_table(:cats)
+        ActiveRecord::Migration.drop_table(:owners)
       end
 
       it "should find the two records that are related to a tag that contains foo record" do
         Dog.search_for('foo').length.should == 2
       end
 
+      it "should find the only record that is related to a tag" do
+        Owner.search_for('foo').length.should == 1
+        Owner.search_for('foo').to_sql.should =~ /taggable_type = 'Dog'/
+      end
+
       it "should find one records that is related to both tags" do
         Dog.search_for('foo=foo AND foo="foo too"').length.should == 1
       end
@@ -720,5 +738,49 @@ ScopedSearch::RSpec::Database.test_databases.each do |db|
         result.first.username.should == @usermat_1.username
       end
     end
+
+    context "querying on :has_many with primary key override" do
+
+      before do
+        ActiveRecord::Migration.create_table(:books) { |t| t.string :title; t.string :isbn }
+        ActiveRecord::Migration.create_table(:comments) { |t| t.string :comment; t.string :isbn }
+
+        class Book < ActiveRecord::Base
+          has_many :comments, foreign_key: 'isbn', primary_key: 'isbn'
+
+          scoped_search on: [:title]
+          scoped_search relation: :comments, on: [:comment]
+        end
+
+        class Comment < ActiveRecord::Base
+          belongs_to :book, foreign_key: 'isbn', primary_key: 'isbn'
+        end
+
+        @book1 = Book.create(:title => 'Eloquent Ruby', :isbn => '978-0321584106')
+        @book2 = Book.create(:title => 'The Well-Grounded Rubyist', :isbn => '978-1617295218')
+        Comment.create(:comment => 'Definitely worth a read', :isbn => @book1.isbn)
+        Comment.create(:comment => 'Wait what? I expected a book about gemstones', :isbn => @book1.isbn)
+        Comment.create(:comment => 'Cool book about ruby', :isbn => @book2.isbn)
+      end
+
+      after do
+        ActiveRecord::Migration.drop_table :comments
+        ActiveRecord::Migration.drop_table :books
+      end
+
+      it "correctly joins the tables" do
+        query = Book.search_for("test").to_sql
+        # On PostgreSQL and SQLite we use double quotes, on MySQL we use backticks
+        query.should =~ /LEFT OUTER JOIN ["`]comments["`] ON ["`]comments["`]\.["`]isbn["`] = ["`]books["`]\.["`]isbn["`]/
+        query.should =~ /["`]books["`]\.["`]isbn["`] IN \(SELECT ["`]isbn["`]/
+      end
+
+      it "finds the right results" do
+        Book.search_for('python').should == []
+        Book.search_for('comment ~ Wait').should == [@book1]
+        Book.search_for('comment ~ book').pluck(:id).sort.uniq.should == [@book1, @book2].map(&:id).sort
+        Book.search_for('comment ~ Cool').should == [@book2]
+      end
+    end
   end
 end

data/spec/lib/database.rb

@@ -48,7 +48,7 @@ module ScopedSearch::RSpec::Database
     ActiveRecord::Migration.create_table(table_name) do |t|
       fields.each do |name, field_type|
         options = (field_type == :decimal) ? { :scale => 2, :precision => 10 } : {}
-        t.send(field_type.to_s.gsub(/^unindexed_/, '').to_sym, name, options)
+        t.send(field_type.to_s.gsub(/^unindexed_/, '').to_sym, name, **options)
       end
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: scoped_search
 version: !ruby/object:Gem::Version
-  version: 4.1.8
+  version: 4.1.9
 platform: ruby
 authors:
 - Amos Benari
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-15 00:00:00.000000000 Z
+date: 2020-08-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -116,6 +116,7 @@ files:
 - spec/integration/auto_complete_spec.rb
 - spec/integration/ext_method_spec.rb
 - spec/integration/key_value_querying_spec.rb
+- spec/integration/nested_has_many_through_querying_spec.rb
 - spec/integration/ordinal_querying_spec.rb
 - spec/integration/profile_querying_spec.rb
 - spec/integration/rails_helper_spec.rb
@@ -173,6 +174,7 @@ test_files:
 - spec/integration/auto_complete_spec.rb
 - spec/integration/ext_method_spec.rb
 - spec/integration/key_value_querying_spec.rb
+- spec/integration/nested_has_many_through_querying_spec.rb
 - spec/integration/ordinal_querying_spec.rb
 - spec/integration/profile_querying_spec.rb
 - spec/integration/rails_helper_spec.rb