Redmine

        # * :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)

          cattr_accessor :searchable_options

          self.searchable_options = options

          if searchable_options[:columns].nil?

          searchable_options[:project_key] ||= "#{table_name}.project_id"

          searchable_options[:date_column] ||= "#{table_name}.created_on"

          searchable_options[:order_column] ||= searchable_options[:date_column]

          # 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?

          send :include, Redmine::Acts::Searchable::InstanceMethods

        end

      end

          base.extend ClassMethods

        end

        module ClassMethods

          # Searches the model for the given tokens

          # projects argument can be either nil (will search all projects), a project or an array of projects

          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[: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 = columns[0..0] if options[:titles_only]

            token_clauses = columns.collect {|column| "(LOWER(#{column}) LIKE ?)"}

            if !options[:titles_only] && searchable_options[:search_custom_fields]

              searchable_custom_field_ids = CustomField.find(:all,

                                                             :select => 'id',

                token_clauses << custom_field_sql

              end

            end

            sql = (['(' + token_clauses.join(' OR ') + ')'] * tokens.size).join(options[:all_words] ? ' AND ' : ' OR ')

            find_options[:conditions] = [sql, * (tokens.collect {|w| "%#{w.downcase}%"} * token_clauses.size).sort]

            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)

                     :include => [:project, :journals],

                     # sort by id so that limited eager loading doesn't break with postgresql

                     :order_column => "#{table_name}.id"

                :url => Proc.new {|o| {:controller => 'issues', :action => 'show', :id => o.id}},

                :type => Proc.new {|o| 'issue' + (o.closed? ? ' closed' : '') }

  acts_as_activity_provider :find_options => {:include => [:project, :author, :tracker]},

                            :author_key => :author_id

  before_save :close_duplicates, :update_done_ratio_from_issue_status

  after_save :reschedule_following_issues, :update_nested_set_attributes, :update_parent_attributes, :create_journal

  after_destroy :update_parent_attributes

  # Returns a SQL conditions string used to find all issues visible by the specified user

  def self.visible_condition(user, options={})

    Project.allowed_to_condition(user, :view_issues, options)

                            :find_options => {:include => [{:issue => :project}, :details, :user],

                                              :conditions => "#{Journal.table_name}.journalized_type = 'Issue' AND" +

                                                             " (#{JournalDetail.table_name}.prop_key = 'status_id' OR #{Journal.table_name}.notes <> '')"}

  named_scope :visible, lambda {|*args| {

    :include => {:issue => :project},

    :conditions => Issue.visible_condition(args.first || User.current)

    c = details.detect {|detail| detail.prop_key == 'status_id'}

    (c && c.value) ? IssueStatus.find_by_id(c.value.to_i) : nil

  end

  def new_value_for(prop)

    c = details.detect {|detail| detail.prop_key == prop}

    c ? c.value : nil

    <div id="search-results-counts">

    <%= render_results_by_type(@results_by_type) unless @scope.size == 1 %>

    </div>

    <h3><%= l(:label_result_plural) %> (<%= @results_by_type.values.sum %>)</h3>

    <dl id="search-results">

      <% end %>

    </dl>

<% end %>

  def setup

    @project = Project.find(1)

  end

  def test_activity_without_subprojects

    events = find_events(User.anonymous, :project => @project)

    assert_not_nil events

  value: New value

  prop_key: 2

  journal_id: 3

  lft: 1

  rgt: 2

issues_008: 

  project_id: 1

  updated_on: <%= 10.days.ago.to_date.to_s(:db) %>

  priority_id: 5

  journalized_type: Issue

  user_id: 1

  journalized_id: 6