search_cop 1.0.1 → 1.0.2

data/README.md

@@ -165,11 +165,10 @@ Obviously, theses queries won't always return the same results as wildcard
 fulltext indices will usually of course provide better performance.
 
 Moreover, the query above is not yet perfect. To improve it even more,
-SearchCop tries to optimize the queries to make optimal use of fulltext
-indices while still allowing to mix them with non-fulltext attributes. To
-improve queries even more, you can group attributes via aliases and specify a
-default field to search in, such that SearchCop must no longer search
-within all fields:
+SearchCop tries to optimize the queries to make optimal use of fulltext indices
+while still allowing to mix them with non-fulltext attributes. To improve
+queries even more, you can group attributes and specify a default field to
+search in, such that SearchCop must no longer search within all fields:
 
 ```ruby
 search_scope :search do
@@ -199,13 +198,14 @@ Book.search("Rowling OR Tolkien stock > 1")
 # PostgreSQL: ... WHERE to_tsvector('simple', books.author || ' ' || books.title) @@ to_tsquery('simple', 'Rowling | Tokien') and books.stock > 1
 ```
 
-What is happening here? Well, we specified `all` as an alias that consists of
-`author` and `title`. As we, in addition, specified `all` to be a fulltext
-attribute, SearchCop assumes there is a compound fulltext index present on
-`author` and `title`, such that the query is optimized accordingly. Finally, we
-specified `all` to be the default attribute to search in, such that
-SearchCop can ignore other attributes, like e.g. `stock`, as long as they
-are not specified within queries directly (like for `stock > 0`).
+What is happening here? Well, we specified `all` as the name of an attribute
+group that consists of `author` and `title`. As we, in addition, specified
+`all` to be a fulltext attribute, SearchCop assumes there is a compound
+fulltext index present on `author` and `title`, such that the query is
+optimized accordingly. Finally, we specified `all` to be the default attribute
+to search in, such that SearchCop can ignore other attributes, like e.g.
+`stock`, as long as they are not specified within queries directly (like for
+`stock > 0`).
 
 Other queries will be optimized in a similar way, such that SearchCop
 tries to minimize the fultext constraints within a query, namely `MATCH()
@@ -338,9 +338,29 @@ class Book < ActiveRecord::Base
 end
 ```
 
-SearchCop will then skip any association auto loading and will use the
-scope instead. Assocations of associations can as well be referenced
-and used:
+SearchCop will then skip any association auto loading and will use the scope
+instead. You can as well use `scope` together with `aliases` to perform
+arbitrarily complex joins and search in the joined models/tables:
+
+```ruby
+class Book < ActiveRecord::Base
+  # ...
+
+  search_scope :search do
+    attributes :similar => ["similar_books.title", "similar_books.description"]
+
+    scope do
+      joins "left outer join books similar_books on ..."
+    end
+
+    aliases :similar_books => Book # Tell SearchCop how to map SQL aliases to models
+  end
+
+  # ...
+end
+```
+
+Assocations of associations can as well be referenced and used:
 
 ```ruby
 class Book < ActiveRecord::Base
@@ -363,7 +383,7 @@ SearchCop tries to infer a model's class name and SQL alias from the
 specified attributes to autodetect datatype definitions, etc. This usually
 works quite fine. In case you're using custom table names via `self.table_name
 = ...` or if a model is associated multiple times, SearchCop however can't
-infer the class and alias names, e.g.
+infer the class and SQL alias names, e.g.
 
 ```ruby
 class Book < ActiveRecord::Base
@@ -392,7 +412,7 @@ class Book < ActiveRecord::Base
   search_scope :search do
     # ...
 
-    aliases :users_books => :user
+    aliases :users_books => User
   end
 
   # ...
@@ -410,7 +430,7 @@ operator regarding a single attribute.
 
 Hash based queries support `:and => [...]` and `:or => [...]`, which take an array
 of `:not => {...}`, `:matches => {...}`, `:eq => {...}`, `:not_eq => {...}`,
-`:lt => {...}`, `:lteq => {...}`, `gt => {...}`, `:gteq => {...}` and `:query => "..."`
+`:lt => {...}`, `:lteq => {...}`, `:gt => {...}`, `:gteq => {...}` and `:query => "..."`
 arguments. Moreover, `:query => "..."` makes it possible to create sub-queries.
 The other rules for query string queries apply to hash based queries as well.
 

data/lib/search_cop/version.rb

@@ -1,3 +1,3 @@
 module SearchCop
-  VERSION = "1.0.1"
+  VERSION = "1.0.2"
 end

data/lib/search_cop.rb

@@ -60,9 +60,10 @@ module SearchCop
 
       query_builder = QueryBuilder.new(self, query, search_scopes[scope_name])
 
-      scope = search_scopes[scope_name].reflection.scope ? instance_exec(&search_scopes[scope_name].reflection.scope) : eager_load(query_builder.associations)
+      scope = instance_exec(&search_scopes[scope_name].reflection.scope) if search_scopes[scope_name].reflection.scope
+      scope ||= eager_load(query_builder.associations) if query_builder.associations.any?
 
-      scope.where query_builder.sql
+      (scope || self).where(query_builder.sql)
     end
   end
 end

data/lib/search_cop_grammar/attributes.rb

@@ -55,15 +55,23 @@ module SearchCopGrammar
         @attributes ||= query_info.scope.reflection.attributes[key].collect { |attribute_definition| attribute_for attribute_definition }
       end
 
-      def klass_for(table)
-        klass = query_info.scope.reflection.aliases[table]
-        klass ||= table
+      def klass_for_association(name)
+        reflections = query_info.model.reflections
 
-        query_info.model.reflections[klass.to_sym] ? query_info.model.reflections[klass.to_sym].klass : klass.classify.constantize
+        return reflections[name.to_sym].klass if reflections[name.to_sym]
+
+        nil
+      end
+
+      def klass_for(name)
+        mapped_name = query_info.scope.reflection.aliases[name]
+        mapped_name ||= name
+
+        klass_for_association(mapped_name) || mapped_name.classify.constantize
       end
 
-      def alias_for(table)
-        (query_info.scope.reflection.aliases[table] && table) || klass_for(table).table_name
+      def alias_for(name)
+        (query_info.scope.reflection.aliases[name] && name) || klass_for(name).table_name
       end
 
       def attribute_for(attribute_definition)

data/test/search_cop_test.rb

@@ -127,5 +127,9 @@ class SearchCopTest < SearchCop::TestCase
     assert_not_nil Product.search_reflection(:search)
     assert_not_nil Product.search_reflection(:user_search)
   end
+
+  def test_blank
+    assert_equal Product.all, Product.search("")
+  end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: search_cop
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-19 00:00:00.000000000 Z
+date: 2014-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: treetop