commontator 5.0.0 → 5.1.0

data/app/models/commontator/comment.rb~

@@ -0,0 +1,124 @@
+module Commontator
+  class Comment < ActiveRecord::Base
+    belongs_to :creator, :polymorphic => true
+    belongs_to :editor, :polymorphic => true
+    belongs_to :thread
+    belongs_to :parent_comment
+
+    validates_presence_of :creator, :on => :create
+    validates_presence_of :editor, :on => :update
+    validates_presence_of :thread
+    validates_presence_of :body
+
+    validates_uniqueness_of :body,
+      :scope => [:creator_type, :creator_id, :thread_id, :deleted_at],
+      :message => I18n.t('commontator.comment.errors.double_posted')
+
+    validate :parent_comment_in_same_thread
+
+    protected
+
+    cattr_accessor :acts_as_votable_initialized
+
+    def parent_comment_in_same_thread
+      return if parent_comment.nil? || parent_comment.thread_id == thread_id
+      errors.add(:parent_comment, 'must belong to the same thread')
+    end
+
+    public
+
+    def is_modified?
+      !editor.nil?
+    end
+
+    def is_latest?
+      thread.comments.last == self
+    end
+
+    def is_votable?
+      return true if acts_as_votable_initialized
+      return false unless self.class.respond_to?(:acts_as_votable)
+      self.class.acts_as_votable
+      self.class.acts_as_votable_initialized = true
+    end
+
+    def get_vote_by(user)
+      return nil unless is_votable? && !user.nil? && user.is_commontator
+      votes_for.where(:voter_type => user.class.name, :voter_id => user.id).first
+    end
+
+    def update_cached_votes(vote_scope = nil)
+      self.update_column(:cached_votes_up, count_votes_up(true))
+      self.update_column(:cached_votes_down, count_votes_down(true))
+    end
+
+    def is_deleted?
+      !deleted_at.blank?
+    end
+
+    def delete_by(user)
+      return false if is_deleted?
+      self.deleted_at = Time.now
+      self.editor = user
+      self.save
+    end
+
+    def undelete_by(user)
+      return false unless is_deleted?
+      self.deleted_at = nil
+      self.editor = user
+      self.save
+    end
+
+    def created_timestamp
+      I18n.t 'commontator.comment.status.created_at',
+             :created_at => I18n.l(created_at, :format => :commontator)
+    end
+    
+    def updated_timestamp
+      I18n.t 'commontator.comment.status.updated_at',
+             :editor_name => Commontator.commontator_name(editor || creator),
+             :updated_at => I18n.l(updated_at, :format => :commontator)
+    end
+
+    ##################
+    # Access Control #
+    ##################
+
+    def can_be_created_by?(user)
+      user == creator && !user.nil? && user.is_commontator &&\
+      !thread.is_closed? && thread.can_be_read_by?(user)
+    end
+
+    def can_be_edited_by?(user)
+      return true if thread.can_be_edited_by?(user) &&\
+                     thread.config.moderator_permissions.to_sym == :e
+      comment_edit = thread.config.comment_editing.to_sym
+      !thread.is_closed? && !is_deleted? && user == creator &&\
+      comment_edit != :n && (is_latest? || comment_edit == :a) &&\
+      thread.can_be_read_by?(user)
+    end
+
+    def can_be_deleted_by?(user)
+      mod_perm = thread.config.moderator_permissions.to_sym
+      return true if thread.can_be_edited_by?(user) &&\
+                     (mod_perm == :e ||\
+                       mod_perm == :d)
+      comment_del = thread.config.comment_deletion.to_sym
+      !thread.is_closed? && (!is_deleted? || editor == user) &&\
+      user == creator && comment_del != :n &&\
+      (is_latest? || comment_del == :a) &&\
+      thread.can_be_read_by?(user)
+    end
+
+    def can_be_voted_on?
+      !thread.is_closed? && !is_deleted? &&\
+      thread.config.comment_voting.to_sym != :n && is_votable?
+    end
+
+    def can_be_voted_on_by?(user)
+      !user.nil? && user.is_commontator && user != creator &&\
+      thread.can_be_read_by?(user) && can_be_voted_on?
+    end
+  end
+end

data/app/models/commontator/subscription.rb~

@@ -0,0 +1,23 @@
+module Commontator
+  class Subscription < ActiveRecord::Base
+    belongs_to :subscriber, :polymorphic => true
+    belongs_to :thread
+
+    validates_presence_of :subscriber, :thread
+    validates_uniqueness_of :thread_id, :scope => [:subscriber_type, :subscriber_id]
+
+    def self.comment_created(comment)
+      recipients = comment.thread.subscribers.reject{|s| s == comment.creator}
+      return if recipients.empty?
+
+      mail = SubscriptionsMailer.comment_created(comment, recipients)
+      (mail.respond_to?(:deliver_later) ? mail.deliver_later : mail.deliver) \
+        unless recipients.empty?
+    end
+
+    def unread_comments
+      created_at = Comment.arel_table[:created_at]
+      thread.filtered_comments.where(created_at.gt(updated_at))
+    end
+  end
+end

data/app/views/commontator/shared/_thread.html.erb~

@@ -0,0 +1,21 @@
+<% # Clients of this partial must supply the following variables:
+   # thread
+   # user
+%>
+
+<% if !thread.can_be_read_by?(user) %>
+  <div id="thread_<%= thread.id %>_div" class="thread" style="display: none;">
+    <% if @commontator_thread_show %>
+      <%= render :partial => 'commontator/threads/show',
+                 :locals => { :thread => thread,
+                              :user => user,
+                              :page => @commontator_page,
+                              :per_page => @commontator_per_page } %>
+    <% else %>
+      <% subscription = thread.subscription_for(user) %>
+      <%= link_to "#{t 'commontator.thread.actions.show'} (#{(subscription.unread_comments.count.to_s + '/') if subscription}#{thread.filtered_comments.count.to_s})",
+                  commontator.thread_path(thread),
+                  :remote => true %>
+    <% end %>
+  </div>
+<% end %>

data/app/views/commontator/subscriptions_mailer/comment_created.html.erb~

@@ -0,0 +1,10 @@
+<h4><%= t 'commontator.email.comment_created.body',
+          :creator_name => @creator_name,
+          :commontable_name => @commontable_name %></h4>
+
+<%= render :partial => 'commontator/comments/body',
+           :locals => { :comment => @comment } %>
+
+<p><%= t 'commontator.email.thread_link_html',
+         :comment_url => @commontable_url,
+         :commontable_name => @commontable_name %></p>

data/app/views/commontator/threads/_hide_show.js.erb~

@@ -0,0 +1,21 @@
+$("#").replaceWith(<%= ej(
+  link_to t('commontator.thread.actions.show'),
+          '#',
+          :id => "thread_#{thread.id.to_s}_show_link",
+          :class => "thread_show_link",
+          :remote => true
+) %>);
+
+$().replaceWith(<%= ej(
+  link_to t('commontator.thread.actions.hide'),
+          '#',
+          :id => "thread_#{thread.id.to_s}_hide_link",
+          :class => "thread_hide_link",
+          :remote => true
+) %>);
+
+      <%= link_to t('commontator.thread.actions.hide'),
+                  '',
+                  :id => "thread_#{thread.id.to_s}_hide_link",
+                  :class => "thread_hide_link",
+                  :remote => true %>

data/app/views/commontator/threads/_hide_show_links.js.erb~

@@ -0,0 +1,17 @@
+<% # Clients of this partial must supply the following variables:
+   # thread
+%>
+
+$("#thread_<%= thread.id %>_hide_link").click(function() {
+  $("#thread_<%= thread.id %>_span").hide();
+
+  $("#thread_<%= thread.id %>_show_span").fadeIn()[0].scrollIntoView();
+});
+
+$("#thread_<%= thread.id %>_show_link").click(function() {
+  $("#thread_<%= thread.id %>_span").fadeIn()[0].scrollIntoView();
+
+  $("#thread_<%= thread.id %>_span").hide();
+});
+
+$("#thread_<%= thread.id %>_hide_span").show();

data/app/views/commontator/threads/_show.html.erb~

@@ -0,0 +1,118 @@
+<% # Clients of this partial must supply the following variables:
+   # thread
+   # user
+   # page
+   # per_page
+   # Optionally, they can also supply the following variable:
+   show_all ||= false
+%>
+
+<% can_subscribe = thread.can_subscribe?(user)
+   can_edit = thread.can_be_edited_by?(user) %>
+
+<span id="thread_<%= thread.id.to_s %>_show_span" class="thread_show commontator_hidden">
+  <%= link_to t('commontator.thread.actions.show'),
+              '#',
+              id: "thread_#{thread.id.to_s}_show_link",
+              class: "thread_show_link" %>
+</span>
+
+<span id="thread_<%= thread.id %>_span" class="thread_span">
+  <span id="thread_<%= thread.id.to_s %>_actions_span" class="thread_actions">
+    <span id="thread_<%= thread.id.to_s %>_hide_span" class="thread_hide commontator_hidden">
+      <%= link_to t('commontator.thread.actions.hide'),
+                  '#',
+                  id: "thread_#{thread.id.to_s}_hide_link",
+                  class: "thread_hide_link" %>
+    </span>
+
+    &nbsp;
+
+    <% if can_subscribe %>
+      <span id="thread_<%= thread.id.to_s %>_subscription_span" class="thread_subscription">
+        <%= render :partial => 'commontator/subscriptions/link',
+                   :locals => { :thread => thread,
+                                :user => user } %>
+      </span>
+    <% end %>
+
+    &nbsp;
+
+    <% if can_edit %>
+      <% filter_string = show_all ? 'filter' : 'show_all'
+         is_closed = thread.is_closed?
+         close_string = is_closed ? 'reopen' : 'close' %>
+
+      <% if thread.is_filtered? %>
+        <%= link_to t("commontator.thread.actions.#{filter_string}"),
+                    commontator.thread_path(thread, :show_all => (show_all ? nil : true)),
+                    :id => "thread_#{thread.id.to_s}_#{filter_string}_link",
+                    :class => "thread_#{filter_string}_link",
+                    :remote => true %>
+
+        &nbsp;
+      <% end %>
+
+      <%= link_to t("commontator.thread.actions.#{close_string}"),
+                  commontator.polymorphic_path([close_string, thread]),
+                  :confirm => (!is_closed ? t('commontator.thread.actions.confirm_close') : nil),
+                  :method => :put,
+                  :id => "thread_#{thread.id.to_s}_#{close_string}_link",
+                  :class => "thread_#{close_string}_link",
+                  :remote => true %>
+    <% end %>
+  </span>
+
+  <span id="thread_<%= thread.id.to_s %>_header_span" class="thread_header">
+    <%= t "commontator.thread.status.#{thread.is_closed? ? 'closed' : 'open'}",
+          :closer_name => (thread.is_closed? ? Commontator.commontator_name(thread.closer) : '') %>
+  </span>
+
+  <% if thread.config.comment_order == :l %>
+    <%= render :partial => 'commontator/threads/reply',
+               :locals => { :thread => thread, :user => user, :per_page => per_page } %>
+  <% end %>
+
+  <div id="thread_<%= thread.id.to_s %>_comment_list_div" class="thread_comment_list">
+    <% comments = show_all ? thread.ordered_comments(true) : \
+                             thread.paginated_comments(page, per_page) %>
+    <%= render :partial => 'commontator/comments/list',
+               :locals => { :comments => comments,
+                            :user => user } %>
+  </div>
+
+  <% if thread.will_paginate? && !show_all %>
+    <div id="thread_<%= thread.id.to_s %>_pagination_div" class="thread_pagination">
+      <div id="thread_<%= thread.id.to_s %>_page_entries_info_div" class="thread_page_entries_info">
+        <%= page_entries_info comments,
+                              :params => { :controller => 'commontator/threads',
+                                           :action => 'show',
+                                           :id => thread.id,
+                                           :page => page,
+                                           :per_page => per_page } %>.
+      </div>
+
+      <div id="thread_<%= thread.id.to_s %>_will_paginate_div" class="thread_will_paginate">
+        <%= will_paginate comments,
+                          :renderer => Commontator::LinkRenderer,
+                          :routes_proxy => commontator,
+                          :remote => true,
+                          :params => { :controller => 'commontator/threads',
+                                       :action => 'show',
+                                       :id => thread.id,
+                                       :page => page,
+                                       :per_page => per_page } %>
+      </div>
+    </div>
+  <% end %>
+
+  <% if thread.config.comment_order != :l %>
+    <%= render :partial => 'commontator/threads/reply',
+               :locals => { :thread => thread, :user => user, :per_page => per_page } %>
+  <% end %>
+</span>
+
+<script type="text/javascript">
+  <%= j(render partial: 'commontator/threads/hide_show_links.js',
+               locals: { thread: thread }) %>
+</script>

data/app/views/commontator/threads/_show.js.erb~

@@ -0,0 +1,18 @@
+<% # Clients of this partial must supply the following variables:
+   # thread
+   # user
+   # page
+   # per_page
+   # Optionally, they can also supply the following variable:
+   show_all ||= false
+%>
+
+$("#thread_<%= thread.id %>_div").replaceWith(
+  "<%= escape_javascript(
+    render :partial => 'commontator/threads/show',
+           :formats => [:html],
+           :locals => { :thread => thread,
+                        :user => user,
+                        :page => page,
+                        :per_page => per_page,
+                        :show_all => show_all }) %>");

data/config/initializers/commontator.rb~

@@ -0,0 +1,290 @@
+# Change the settings below to suit your needs
+# All settings are initially set to their default values
+
+# Note: Do not "return" from a Proc, use "next" instead if necessary
+#       "return" in a lambda is OK
+Commontator.configure do |config|
+  # Engine Configuration
+
+  # current_user_proc
+  # Type: Proc
+  # Arguments: the current controller (ActionController::Base)
+  # Returns: the current user (acts_as_commontator)
+  # The default works for Devise and similar authentication plugins
+  # Default: lambda { |controller| controller.current_user }
+  config.current_user_proc = lambda { |controller| controller.current_user }
+
+  # javascript_proc
+  # Type: Proc
+  # Arguments: a view (ActionView::Base)
+  # Returns: a String that is appended to Commontator JS views
+  # Can be used, for example, to display/clear Rails error messages
+  # or to reapply JQuery UI styles after Ajax calls
+  # Objects visible in view templates can be accessed
+  # through the view object (for example, view.flash)
+  # However, the view does not include the main application's helpers
+  # Default: lambda { |view| '$("#error_explanation").remove();' }
+  config.javascript_proc = lambda { |view|
+                                    '$("#error_explanation").remove();' }
+
+
+
+  # User (acts_as_commontator) Configuration
+
+  # user_name_proc
+  # Type: Proc
+  # Arguments: a user (acts_as_commontator)
+  # Returns: the user's name (String)
+  # Default: lambda { |user| I18n.t('commontator.anonymous') } (all users are anonymous)
+  config.user_name_proc = lambda { |user| I18n.t('commontator.anonymous') }
+
+  # user_link_proc
+  # Type: Proc
+  # Arguments: a user (acts_as_commontator),
+  #            the app_routes (ActionDispatch::Routing::RoutesProxy)
+  # Returns: a path to the user's `show` page (String)
+  # If anything non-blank is returned, the user's name in comments
+  # comments will become a hyperlink pointing to this path
+  # The main application's routes can be accessed through the app_routes object
+  # Default: lambda { |user, app_routes| '' } (no link)
+  config.user_link_proc = lambda { |user, app_routes| '' }
+
+  # user_avatar_proc
+  # Type: Proc
+  # Arguments: a user (acts_as_commontator), a view (ActionView::Base)
+  # Returns: a String containing a HTML <img> tag pointing to the user's avatar image
+  # The commontator_gravatar_image_tag helper takes a user object,
+  # a border size and an options hash for Gravatar, and produces a Gravatar image tag
+  # See available options at http://en.gravatar.com/site/implement/images/)
+  # Note: Gravatar has several security implications for your users
+  #       It makes your users trackable across different sites and
+  #       allows de-anonymization attacks against their email addresses
+  #       If you absolutely want to keep users' email addresses or identities secret,
+  #       do not use Gravatar or similar services
+  # Default: lambda { |user, view|
+  #            view.commontator_gravatar_image_tag(
+  #              user, 1, :s => 60, :d => 'mm') }
+  config.user_avatar_proc = lambda { |user, view|
+                                     view.commontator_gravatar_image_tag(
+                                       user, 1, :s => 60, :d => 'mm') }
+
+  # user_email_proc
+  # Type: Proc
+  # Arguments: a user (acts_as_commontator), a mailer (ActionMailer::Base)
+  # Returns: the user's email address (String)
+  # The default works for Devise's defaults
+  # If the mailer argument is nil, Commontator intends to hash the email and send the hash
+  # to Gravatar, so you should always return the user's email address (if using Gravatar)
+  # If the mailer argument is not nil, then Commontator intends to send an email to
+  # the address returned; you can prevent it from being sent by returning a blank String
+  # Default: lambda { |user, mailer| user.try(:email) || '' }
+  config.user_email_proc = lambda { |user, mailer| user.try(:email) || '' }
+
+
+
+  # Thread/Commontable (acts_as_commontable) Configuration
+
+  # comment_filter
+  # Type: Arel node (Arel::Nodes::Node) or nil
+  # Arel that filters visible comments
+  # If specified, visible comments will be filtered according to this Arel node
+  # A value of nil will cause no filtering to be done
+  # Moderators can manually override this filter for themselves
+  # Example: Commontator::Comment.arel_table[:deleted_at].eq(nil) (hides deleted comments)
+  #          This is not recommended, as it can cause confusion over deleted comments
+  #          If using pagination, it can also cause comments to change pages
+  # Default: nil (no filtering - all comments are visible)
+  config.comment_filter = nil
+
+  # thread_read_proc
+  # Type: Proc
+  # Arguments: a thread (Commontator::Thread), a user (acts_as_commontator)
+  # Returns: a Boolean, true iif the user should be allowed to read that thread
+  # Note: can be called with a user object that is nil (if they are not logged in)
+  # Default: lambda { |thread, user| true } (anyone can read any thread)
+  config.thread_read_proc = lambda { |thread, user| true }
+
+  # thread_moderator_proc
+  # Type: Proc
+  # Arguments: a thread (Commontator::Thread), a user (acts_as_commontator)
+  # Returns: a Boolean, true iif the user is a moderator for that thread
+  # If you want global moderators, make this proc true for them regardless of thread
+  # Default: lambda { |thread, user| false } (no moderators)
+  config.thread_moderator_proc = lambda { |thread, user| false }
+
+  # comment_editing
+  # Type: Symbol
+  # Whether users can edit their own comments
+  # Valid options:
+  #   :a (always)
+  #   :l (only if it's the latest comment)
+  #   :n (never)
+  # Default: :l
+  config.comment_editing = :l
+
+  # comment_deletion
+  # Type: Symbol
+  # Whether users can delete their own comments
+  # Valid options:
+  #   :a (always)
+  #   :l (only if it's the latest comment)
+  #   :n (never)
+  # Note: For moderators, see the next option
+  # Default: :l
+  config.comment_deletion = :l
+
+  # moderator_permissions
+  # Type: Symbol
+  # What permissions moderators have
+  # Valid options:
+  #   :e (delete and edit comments and close threads)
+  #   :d (delete comments and close threads)
+  #   :c (close threads only)
+  # Default: :d
+  config.moderator_permissions = :d
+
+  # comment_voting
+  # Type: Symbol
+  # Whether users can vote on other users' comments
+  # Valid options:
+  #   :n  (no voting)
+  #   :l  (likes - requires acts_as_votable gem)
+  #   :ld (likes/dislikes - requires acts_as_votable gem)
+  # Not yet implemented:
+  #   :s  (star ratings)
+  #   :r  (reputation system)
+  # Default: :n
+  config.comment_voting = :n
+
+  # vote_count_proc
+  # Type: Proc
+  # Arguments: a thread (Commontator::Thread), pos (Fixnum), neg (Fixnum)
+  # Returns: vote count to be displayed (String)
+  # pos is the number of likes, or the rating, or the reputation
+  # neg is the number of dislikes, if applicable, or 0 otherwise
+  # Default: lambda { |thread, pos, neg| "%+d" % (pos - neg) }
+  config.vote_count_proc = lambda { |thread, pos, neg| "%+d" % (pos - neg) }
+
+  # comment_order
+  # Type: Symbol
+  # What order to use for comments
+  # Valid options:
+  #   :e  (earliest comment first)
+  #   :l  (latest comment first)
+  #   :ve (highest voted first; earliest first if tied)
+  #   :vl (highest voted first; latest first if tied)
+  # Notes:
+  #   :e is usually used in forums (discussions)
+  #   :l is usually used in blogs (opinions)
+  #   :ve and :vl are usually used where it makes sense to rate comments
+  #     based on usefulness (q&a, reviews, guides, etc.)
+  # If :l is selected, the "reply to thread" form will appear before the comments
+  # Otherwise, it will appear after the comments
+  # Default: :e
+  config.comment_order = :e
+
+  # new_comment_style
+  # Type: Symbol
+  # How to display the "new comment" form
+  # Valid options:
+  #   :t (always present in the thread's page)
+  #   :l (link to the form; opens in the same page using JS)
+  # Not yet implemented:
+  #   :n (link to the form; opens in a new window)
+  # Default: :l
+  config.new_comment_style = :l
+
+  # comments_per_page
+  # Type: Fixnum or nil
+  # Number of comments to display in each page
+  # Set to nil to disable pagination
+  # Any other value requires the will_paginate gem
+  # Default: nil (no pagination)
+  config.comments_per_page = nil
+
+  # thread_subscription
+  # Type: Symbol
+  # Whether users can subscribe to threads to receive activity email notifications
+  # Valid options:
+  #   :n (no subscriptions)
+  #   :a (automatically subscribe when you comment; cannot do it manually)
+  #   :m (manual subscriptions only)
+  #   :b (both automatic, when commenting, and manual)
+  # Default: :n
+  config.thread_subscription = :n
+
+  # email_from_proc
+  # Type: Proc
+  # Arguments: a thread (Commontator::Thread)
+  # Returns: the address emails are sent "from" (String)
+  # Important: If using subscriptions, change this to at least match your domain name
+  # Default: lambda { |thread|
+  #                   "no-reply@#{Rails.application.class.parent.to_s.downcase}.com" }
+  config.email_from_proc = lambda { |thread|
+    "no-reply@#{Rails.application.class.parent.to_s.downcase}.com" }
+
+  # commontable_name_proc
+  # Type: Proc
+  # Arguments: a thread (Commontator::Thread)
+  # Returns: a name that refers to the commontable object (String)
+  # If you have multiple commontable models, you can also pass this
+  # configuration value as an argument to acts_as_commontable for each one
+  # Default: lambda { |thread|
+  #                   "#{thread.commontable.class.name} ##{thread.commontable.id}" }
+  config.commontable_name_proc = lambda { |thread|
+    "#{thread.commontable.class.name} ##{thread.commontable.id}" }
+
+  # comment_url_proc
+  # Type: Proc
+  # Arguments: a comment (Commontator::Comment),
+  #            the app_routes (ActionDispatch::Routing::RoutesProxy)
+  # Returns: a String containing the url of the view that displays the given comment
+  # This usually is the commontable's "show" page
+  # The main application's routes can be accessed through the app_routes object
+  # Default: lambda { |comment, app_routes|
+<<<<<<< Updated upstream
+  #            app_routes.polymorphic_url(comment.thread.commontable) }
+  # Link to comment:
+  #          lambda { |comment, app_routes|
+  #            app_routes.polymorphic_url(comment.thread.commontable, anchor: "comment_#{comment.id}_div") }
+  # (defaults to the commontable's show url)
+  config.commontable_url_proc = lambda { |comment, app_routes|
+    app_routes.polymorphic_url(comment.thread.commontable) }
+=======
+  #                   app_routes.polymorphic_url(comment.thread.commontable,
+  #                                              anchor: "comment_#{comment.id}_div") }
+  # (defaults to the commontable's show url with an anchor pointing to the comment's div)
+  config.comment_url_proc = lambda { |comment, app_routes|
+    app_routes.polymorphic_url(comment.thread.commontable, anchor: "comment_#{comment.id}_div") }
+>>>>>>> Stashed changes
+
+  # mentions_enabled
+  # Type: Boolean
+  # Whether users can mention other users to subscribe them to the thread
+  # Valid options:
+  #   false (no mentions)
+  #   true  (mentions enabled)
+  # Default: false
+  config.mentions_enabled = false
+
+  # user_mentions_proc
+  # Type: Proc
+  # Arguments:
+  #   the current user (acts_as_commontator)
+  #   the search query inputted by user (String)
+  # Returns: an ActiveRecord Relation object
+  # Important notes:
+  #
+  #  - The proc will be called internally with an empty search string.
+  #    In that case, it MUST return all users that can be mentioned.
+  #
+  #  - With mentions enabled, any registered user in your app is able
+  #    to call this proc with any search query >= 3 characters.
+  #    Make sure to handle SQL escaping properly and that the
+  #    attribute being searched does not contain sensitive information.
+  #
+  # Default: lambda { |current_user, query|
+  #                   current_user.class.where('username LIKE ?', "#{query}%") }
+  config.user_mentions_proc = lambda { |current_user, query|
+    current_user.class.where('username LIKE ?', "#{query}%") }
+end