So Codaset now has full site searching, which I gotta say is really very useful! It was also surprisingly easy to setup and code, thanks mainly to the power of Sphinx, and its Rails plugin counterpart: Thinking Sphinx. So here's how to implement full text searching within your Rails apps.

Install Sphinx

Just run the following three commands on your server or dev machine to install Sphinx:

./configure
make
sudo make install

That will setup Sphinx with default for use with MySQL. If you want to use it with PostgreSQL, then run configure with the following flag:

./configure --with-pgsql

Install Thinking Sphinx

Even though there are a couple of Sphinx plugins for Rails, I chose to go with Thinking Sphinx, as it seems to be the most popular and feature complete. So you can install it as a Rails plugin using the script/plugin install command:

script/plugin install git://github.com/freelancing-god/thinking-sphinx.git

Or like me, you can install the Gem:

sudo gem install freelancing-god-thinking-sphinx --source http://gems.github.com

Then add the gem to my config/environment.rb:

config.gem "freelancing-god-thinking-sphinx", :lib => "thinking_sphinx", :source => "http://gems.github.com"

If you do go the Gem route, then you will have to do one extra task. Just append the following like to your app's rakefile to make the Thinking Sphinx rake tasks available to you:

require 'thinking_sphinx/tasks'

Create your Sphinx Indexes

This post is a quick guide on how to get up and running quickly with Sphinx and your Rails app's, so I won't be talking about how Sphinx works and what exactly it does. So before you continue, you should at least read an introduction to Sphinx. And if you get stuck (which you shouldn't as this is easy peasy!) check out the Sphinx reference and the Thinking Sphinx site.

So now you know all about Sphinx and how it works, we now need to index our models. This consists of adding a few small lines of code into each model that you want to be able to search.

So lets say we have a Blog app (doesn't everyone!), which has a Post model. And that Post model contains the usual title and description fields. We therefore add the following bit of code beneath our association declarations in app/models/post.rb:

define_index do
  indexes title, description
end

Those very short three lines will tell Thinking Sphinx to index the title and description fields of the Post model, and allow us to search through all our posts. Now we just need to index and start Sphinx. And Thinking Sphinx makes this very easy with it's handy Rake tasks. Just run this:

rake ts:rebuild

That will stop (if it is started), index and start Sphinx for you.

Now we need to create a quick search form. This will eventually be a global site search, and not just a Post search. So we will create a new controller:

script/generate controller search

Then create a view at app/views/search/index.html.erb and place the form within it:

<%- form_tag { :controller => 'search', :action => 'create' } do -%>
  <%= text_field_tag :search %>
  <%= submit_tag 'Search' %>
<%- end -%>

Now in your new Search controller, create a new create action:

def create
  @posts = Post.search params[:search]
end

Create your create view at app/views/search/create.html.erb with a bit of code to display your @posts in the usual way. When you enter a search term into our new search form, and submit it, ThinkingSphinx will search through Sphinx's index for the Post model, and return a list of ActiveRecord model records. Which makes it very easy to deal with the results. Just treat them like any other set of AR records.

We can even paginate our results using the WillPaginate plugin:

def create
  @posts = Post.search params[:search], :page => params[:page], :per_page => 10
end

Search all Your Models

Now we also have a few other models, such as a Comment and a User model, and want to be able to search across them all with one search form, and be presented with a summary of all those model records that match our search.

First, we need to index our Comment and User models in the same way as we did with the Post model. Just use the same syntax for each model, but using the fields that you want to index within that model only. So the Comment model has just a comments field:

define_index do
  indexes comments
end

And the User model:

define_index do
  indexes [ first_name, last_name ], :as => :full_name
end

So now we have three models to search across, so we need to modify our controller a little. We could call the search method on each model, but we're not going to. Thinking Sphinx gives us something even better:

def create
  @results = ThinkingSphinx.search params[:search]
end

The above will search across all indexed models, which in this case is the Post, Comment and User models, and the return a mixed list of AR records.

Summary

So this wsa just a basic tutorial, but I hope it conveys how easy and also how powerful this search solution is. You should take time to read through the Thinking Sphinx site, oh and don't forget to take a look at the Codaset search. It uses the same setup as I have mentioned here, albeit with a few little extras thrown in, including facets and attributes.

Enjoy!