Merged trunk r1773.

git-svn-id: http://redmine.rubyforge.org/svn/branches/work@1774 e93f8b46-1217-0410-a6f0-8f06a7374b81

groups/vendor/plugins/acts_as_searchable/lib/acts_as_searchable.rb

@@ -23,6 +23,12 @@ module Redmine
       end 
 
       module ClassMethods
+        # Options:
+        # * :columns - a column or an array of columns to search
+        # * :project_key - project foreign key (default to project_id)
+        # * :date_column - name of the datetime column (default to created_on)
+        # * :sort_order - name of the column used to sort results (default to :date_column or created_on)
+        # * :permission - permission required to search the model (default to :view_"objects")
         def acts_as_searchable(options = {})
           return if self.included_modules.include?(Redmine::Acts::Searchable::InstanceMethods)
   
@@ -35,19 +41,12 @@ module Redmine
             searchable_options[:columns] = [] << searchable_options[:columns]
           end
 
-          if searchable_options[:project_key]
-          elsif column_names.include?('project_id')
-            searchable_options[:project_key] = "#{table_name}.project_id"
-          else
-            raise 'No project key defined.'
-          end
+          searchable_options[:project_key] ||= "#{table_name}.project_id"
+          searchable_options[:date_column] ||= "#{table_name}.created_on"
+          searchable_options[:order_column] ||= searchable_options[:date_column]
           
-          if searchable_options[:date_column]
-          elsif column_names.include?('created_on')
-            searchable_options[:date_column] = "#{table_name}.created_on"
-          else
-            raise 'No date column defined defined.'
-          end
+          # Permission needed to search this model
+          searchable_options[:permission] = "view_#{self.name.underscore.pluralize}".to_sym unless searchable_options.has_key?(:permission)
           
           # Should we search custom fields on this model ?
           searchable_options[:search_custom_fields] = !reflect_on_association(:custom_values).nil?
@@ -62,13 +61,24 @@ module Redmine
         end
 
         module ClassMethods
-          def search(tokens, project, options={})
+          # Searches the model for the given tokens
+          # projects argument can be either nil (will search all projects), a project or an array of projects
+          # Returns the results and the results count
+          def search(tokens, projects=nil, options={})
             tokens = [] << tokens unless tokens.is_a?(Array)
+            projects = [] << projects unless projects.nil? || projects.is_a?(Array)
+            
             find_options = {:include => searchable_options[:include]}
-            find_options[:limit] = options[:limit] if options[:limit]
-            find_options[:order] = "#{searchable_options[:date_column]} " + (options[:before] ? 'DESC' : 'ASC')
+            find_options[:order] = "#{searchable_options[:order_column]} " + (options[:before] ? 'DESC' : 'ASC')
+            
+            limit_options = {}
+            limit_options[:limit] = options[:limit] if options[:limit]
+            if options[:offset]
+              limit_options[:conditions] = "(#{searchable_options[:date_column]} " + (options[:before] ? '<' : '>') + "'#{connection.quoted_date(options[:offset])}')"
+            end
+            
             columns = searchable_options[:columns]
-            columns.slice!(1..-1) if options[:titles_only]
+            columns = columns[0..0] if options[:titles_only]
             
             token_clauses = columns.collect {|column| "(LOWER(#{column}) LIKE ?)"}
             
@@ -87,21 +97,23 @@ module Redmine
             
             sql = (['(' + token_clauses.join(' OR ') + ')'] * tokens.size).join(options[:all_words] ? ' AND ' : ' OR ')
             
-            if options[:offset]
-              sql = "(#{sql}) AND (#{searchable_options[:date_column]} " + (options[:before] ? '<' : '>') + "'#{connection.quoted_date(options[:offset])}')"
-            end
             find_options[:conditions] = [sql, * (tokens * token_clauses.size).sort]
             
-            results = with_scope(:find => {:conditions => ["#{searchable_options[:project_key]} = ?", project.id]}) do
-              find(:all, find_options)
-            end            
-            if searchable_options[:with] && !options[:titles_only]
-              searchable_options[:with].each do |model, assoc|
-                results += model.to_s.camelcase.constantize.search(tokens, project, options).collect {|r| r.send assoc}
+            project_conditions = []
+            project_conditions << (searchable_options[:permission].nil? ? Project.visible_by(User.current) :
+                                                 Project.allowed_to_condition(User.current, searchable_options[:permission]))
+            project_conditions << "#{searchable_options[:project_key]} IN (#{projects.collect(&:id).join(',')})" unless projects.nil?
+            
+            results = []
+            results_count = 0
+            
+            with_scope(:find => {:conditions => project_conditions.join(' AND ')}) do
+              with_scope(:find => find_options) do
+                results_count = count(:all)
+                results = find(:all, limit_options)
               end
-              results.uniq!
             end
-            results
+            [results, results_count]
           end
         end
       end