Having recently implemented Thinking Sphinx on one of my web sites, I thought it would be cool to be able to search every indexed model. With Thinking Sphinx, it’s easy to have a bunch of different classes returned in the results. The tougher part is displaying them in a way that is organized (although admittedly not very DRY).

Let’s start out with the controller method for search results (app/controllers/search_controller.rb):

Also, let’s make sure we define the actual search model. I define it in a separate search library (lib/search.rb). This is the relevant snippet of code:

Assuming that we are working with the all models search, where the above model is ThinkingSphinx, let’s iterate over the search results with this code in the view (app/views/search/results.html.erb):

And the view helper (app/helpers/search_helper.rb):

The interesting thing about this bit of code is the eval. The eval on each iteration decides which search result partial to display based on the class and then passes the result to the partial for display. So if the result has a class of Business, the partial app/views/businesses/_result.html.erb will be rendered. This is a quick example of a search result partial:

This is useful because all models don’t have the same characteristics. By creating a search result partial for each model type, this can be reused for consistent looking search results around your webapp. If the search is model specific, the same result partial will be used in every iteration over the results. If the search is model agnostic, then you can display your search results in a consistent manner.

Related posts:

1. Sortfix Or A Next Generation Search Tool
2. Adding An Average Column To A Model
3. MySQL Encoded URI Search and Replace

SEO being an interest of mine, I couldn’t quite wrap my head around releasing a webapp without a sitemap. The problem is that there aren’t any really great sitemap plugins for Rails. Now I will grant that creating a sitemap in Rails is a challenging proposition and one that I would not like to undertake on my own unless absolutely necessary. But I was hoping that there would be a rails sitemap “killer app” like there is with almost everything else in Rails.

So I dove in and tried a few options until I found one that worked. First I wrote some code to generate an XML file and then created a sitemap_index.xml.gz file by hand. This was very kludgy and definitely not a permanent solution. I had also read suggestions about doing it in a sitemap_controller.rb file, but that seemed just as kludgy as using a view to generate the XML. It was then time to explore the plugin world.

After trying a few random plugins that I stumbled across, I finally found one that works for me. It’s call sitemap_generator by Adam Salter. What I really like about it is that it supports actually Ruby code in the config/sitemap.rb file. Additionally, it solves a few common sitemap problems from the getgo (taken from the github README):
* Support for more than 50,000 urls (using a Sitemap Index file)
* Gzip of Sitemap files
* Variable priority of links
* Paging/sorting links (e.g. my_list?page=3)
* SSL host links (e.g. https:)
* Rails apps which are installed on a sub-path (e.g. example.com/blog_app/)

Using this plugin is easy. Install it just as you would install any other plugin or gem (instructions are in the README). Getting right into the sitemap, it’s really easy to accomplish whatever you want to do using regular Ruby code. For example, if I simply want to find all the businesses on the site and add them to the sitemap, I can do this:

And if I have a slightly more complex URL structure like this one for posts (and who doesn’t have a posts model in their webapp):

Then I can do something a little more complex like this:

The only thing that I can’t seem to figure out if it supports is custom links in the URLs. Meaning links that are fairly convoluted and (for some reason) not generated with a link_to, but have a custom link generator. Other than that, you should probably go with sitemap_generator for your sitemap needs.

If you have a favorite Rails plugin for sitemaps, I would certainly like to hear about it. And if you aren’t using sitemaps and are worried about SEO, then shame on you.

Related posts:

1. Testing Sessions with Digest::SHA256 Passwords In Rails

In one my Rails applications, I allow the user to search for surrounding businesses from their current location. I always showed them a You Are Here marker. The issue I had with this was that the marker was always the icon as the search results. Differentiating these markers is actually extremely easy with ym4r_gm plugin.

First thing is to find a custom icon that you want to use. You can just Google for custom Google maps icons. I chose to use their default icon, just in a different blue. (You can download it here so you are working with what I am working with for this example). The next thing I did was to use the Google custom markers web site to find the proper config options for the icon.

The Rails code is just used to create Javascript. That is why it’s a good idea to run the image through custom markers website to get the Javascript output. Ym4r_gm just turns the Ruby options specified into Javascript. There are more options available, but this is the bare minimum necessary to create a separate icon. All you need to do is use the option names given to you by the custom markers site and “Rubyify” them in GIcon.new (note: this is slightly harder than it sounds).

A few things worth nothing about this code in order to better understand what it’s doing.

If you don’t have the icon_size set properly, then your icon will look funny when the map renders. The icon_anchor and info_window_anchor are just coincidentally half of 32, this is not always the case. And that last item in GIcon.new is what is going to be the Javascript variable name. For sanity’s sake, I chose to keep the Ruby variable name and Javascript variable names consistent. The Variable.new line creates a ym4r_gm icon object in Ruby to be passed to the :icon parameter of the youarehere marker.

The rest of the code is similar to your regular ym4r_gm map icon stuff.

Related posts:

1. Transferring Email From Gmail/Google Apps to Dovecot With Larch
2. One Time Modal Windows With Rails and Fancybox
3. Getting Rid of The Google Analytics Overlay

I’ve been wanting to find a way to use drop down menus for countries and their states when they exist. But keeping a list on my own would have been a huge pain in the ass. So rather reinvent the wheel, I found the Carmen plugin for Rails. All I have to do is keep the plugin updated and my list of countries and their states will be kept updated as well.

How do I do all this with unobtrusive Javascript and Rails you ask? Good question. Let me show you. Don’t forget to install the plugin (or use the gem).

Let’s start out by adding the drop down menu to our view. In my case I have it in a partial for the address part of a form. You’ll have to modify this slightly to pick up the values of the form if the partial handles edits as well. This one is just for a new method as it uses a default country of US and its states. Note the div ID here of addressStates; we will be using this later in the javascript.

Since we are rendering a partial, we should add that partial as well. Create the file app/views/addresses/_states.html.erb and add the code below. You’ll notice that if no set of states exist in the country selected, I render a text_field instead. This is obviously optional and could potentially lead to issues if the list of states for a particular country is updated and the values in your DB don’t match.

Now, let’s update our application.js file. Because of the way the form is laid out, my element ID works out to be address_country. Make sure you use the correct element ID otherwise the action will not fire. (Thanks to Joel for helping with the javascript).

You’ll notice that when we populate the div, we wrap it in javascript <script> tags. This is because the response we get is an AJAX response. In order for the browser to render it properly, we need to wrap it in script tags.

Before the above Javascript will work, we have to setup a route specifically to handle this request. So add the following code to your config/routes.rb. I chose to put this in the addresses controller (since it’s a functional part of an address, it just seemed logical), but feel free to put it wherever you see fit. Just make sure you then add the method to the proper controller.

Now we need to add the method to our controller. As I said, I chose the addresses controller in my project because its logical. So I opened up the app/controllers/addresses_controller.rb and added the following code.

And there you have it. A straightforward way to keep your list of countries and states updated and consistent. Hope this works for you as well as it does for me.

Related posts:

1. Checking Roles in Views Using RoleRequirement
2. One Time Modal Windows With Rails and Fancybox
3. Model Specific Formatted Search Results Using Thinking Sphinx

In part 1 of this series, we discussed the base models, controller, database migrations necessary to get this project off the ground. Now we are going to continue with this functionality

Let’s take a look at what needs to go into the models to support this. If you have a model that uses a slug generated via to_param, then your code will look like the top model, If you are using the normal numeric id convention, then it will look like the bottom model. The reason for the specifically named methods get_title and get_description will become apparent when you start displaying bookmarks. The thought process is that you can use a consistent set of calls for displaying the bookmark information and put the code to grab that information in the model where it belongs rather than loading up the helper methods. What should also be noted is that the title and description fields are not always consistent across models. Therefore the method naming conventions returns the proper column with consistent method names.

Slug based model:

Numeric ID based model:

Now that we have the code in our models, controllers, and the database is setup, let’s put it into our views so we can actually take advantage of our bookmark system. Let’s dive right in to adding the code. Inside our show view, we just add the lines below. We check to see if the user is logged in. If they are, check their bookmark status of this page and show the appropriate image.

The are a few helper methods that are required here to support this functionality. The bookmarks_helper.rb looks as follows. Notice the use of the send method in the link_to_bookmark method. That enables us to abstract the link_to to be for any model_path that you have in the Bookmarktypes.

You’ll recognize some of this code from the model and the controller. I know this isn’t necessarily DRY, but I am by no means a Rails expert. But I do know this code works.

The last item to tie this whole thing together is allowing the user to view their bookmarks. We already have the code for the show page in our controller. Keeping that in mind, let’s take a look at using that and our helper methods to give a decent presentation of our bookmarks.

And there you have it. Your users can now bookmark pages and view their list of bookmarks in a profile type setting. There might be other ways to do this, but this way has worked for me thus far. Good luck.

Related posts:

1. Adding AJAX Bookmarks to Your Rails Application (Part 1 of 2)
2. Model Specific Formatted Search Results Using Thinking Sphinx
3. Shortcut Notation in Rails Callbacks

It you want to add the ability to bookmark pages in your Rails application, its actually a fairly straightforward thing to do. You can even do them in AJAX. There may be better ways to do this, but this way is somewhat abstract and it works for me, so hopefully it can work for you too. It is abstract in the sense that it will work for models with different URL styles and different column names.

The way this works is that you add a bookmark icon (which is initially disabled) to a show <model_name> page. When the user clicks on the bookmark icon, an AJAX query will be made in the background and update the users bookmark lists. I am approaching this from an abstract methodology. Meaning that I have “forced” these methods to work with models executed in various fashions (as I give examples of below). The AJAX call is going to be simply work as a toggle. It will actually call a toggle method in the bookmarks controller and change the current value and replace the image. The user can then view the pages they have bookmarked in their profile.

I have decided to break this into a multi-part blog entry because it ends up being quite long. Not necessarily in how long it takes, just the amount of space it takes to show all the code. I have done my best to only show relevant code and maintain brevity. Note: I will not cover how to allow for unobtrusive AJAX calls. That is beyond the scope of this set of posts.

I chose the following images to represent this. The empty blue star signifies that a bookmark is disabled. The filled in blue star represents the fact that the page is bookmarked by the current user. You can go to Google images or anywhere else to find enabled/disabled images. I just chose these particular images because they matched my site.

Star Bookmark Enabled

Star Bookmark Disabled

The first thing you need to do is to create the migrations for bookmarks and bookmarktypes. Make sure the bookmarktypes exist for every model that you want to allow to be bookmarked and are the singularized lowercase version of the model name (e.g. Users -> user, Businesses -> business).

Here we are adding the bookmark and bookmarktype model.

Once the models and migrations are complete, then we can go ahead and add the controller code. Create a bookmarks controller. This will contain the toggle method that will be doing the majority of the legwork. You’ll notice that the toggle method below uses a url param. This works in the following way:

1. When the AJAX link is clicked on the model show view page, it will send an AJAX request to bookmarks controller that looks like this:
   • http://website/bookmarks/toggle?url=/businesses/mybusiness&_=1258315454002
   • http://localhost/bookmarks/toggle?url=/user/1234&_=1258315600823

   The _ param is simply the authenticity token put into a GET string.

2. The URL parameter will be broken down into an array:
   • [0]: empty   OR   empty
   • [1]: businesses   OR   user
   • [2]: mybusiness   OR   1234
3. We get the modeltype (which will soon act just like a class like you would call Business.find or User.find). We do this by capitalizing it and constantizing it. We capitalize it so it looks like the model class name otherwise we generate a nomethod error. Constantizing the model name turns it into something that is usable as a class: Bookmarktype.find_by_model(uri_array[1].singularize).model.capitalize.constantize
4. This is where it gets interesting and you get to deal with multiple types of URLs in a model: modeltype.find_id_by_site_url(request_uri). The find_id_by_site_url method is a method that requires definition in each model because it can be different in each model. We will cover this later.
5. Then we check to see if the bookmark exists by calling the find method we wrote in our Bookmark model. We use the result to determine whether the bookmark should be added or removed in the actual toggle process.
6. The bookmark status is toggled in the database, either added or deleted. The delete_all method is used because there is no way in Rails (that I could find) to delete a row with no primary key.
7. Finally, the Javascript is rendered so nothing happens to the original calling page.

And finally, here is the actual bookmarks controller. We will go through the usage of the show method later.

Lastly on the AJAX side of this, we need to put response view together. This is a very simple line of code in the toggle.js.erb:

And for the unobtrusive aspect of Javascript and in the interest of keeping Javascript all in the same place, add that function to your application.js:

Click here for part 2 of this series.

Related posts:

1. Adding AJAX Bookmarks to Your Rails Application (Part 2 of 2)
2. One Time Modal Windows With Rails and Fancybox
3. Shortcut Notation in Rails Callbacks

Let’s say that you have a situation that you want to have a modal window show up only once for each user. It’s actually not that difficult although lots of Googling around got me nowhere. I am choosing to use FancyBox for my modal window, but feel free to use your modal framework of choice. So let’s get down to business.

First thing you’ll need to do is download FancyBox and copy the stylesheets, images, and Javascript files to their proper/desired location in your Rails app. Style the window according to your likings.

Whether it is right or wrong, I did this entirely in the view, without even pulling the Javascript out into the application.js (or even another Javascript file for that matter). My reason was that I only want the modal window showing up on this page. If you want your modal window to show up somewhere else (or on every page), then put the code in your layout. But remember that this call will be executed every time the page loads. I put mine in a profile page which doesn’t get accessed that often so the conditional is not checked quite as frequently.

My application uses Facebook Connect and grabs the users Facebook Proxy email address (FB app developers will know what this is). So I check if that’s the email I have for the user. If yes, then I pop up a modal window on page load only once to get their regular email address and possibly a password so they can login to their account without Facebook Connect if they want. When the modal window is shown, a variable is set in the cookie (note that this cookie is shared with authlogic for sessions) to ensure that the modal window isn’t shown again.

The explanation of the code is below with comments in the code.

The code that goes in the view is as follows:

Now you have a modal window that is only shown once.

Related posts:

1. Testing Sessions with Digest::SHA256 Passwords In Rails
2. Adding AJAX Bookmarks to Your Rails Application (Part 1 of 2)
3. Country-State Select Using Carmen and jQuery

Normally when do a database migration in Rails, when adding ownership from a model to another model, you use the concept of belongs_to or references:

Interestingly enough, these methods are only available during the initial table creation. If you want to add a reference to a model that is created later, you have to do it the old fashioned way, by just adding a column:

Doing it this way is clean, easy, and definitely meets the KISS principle. But I do find it interesting that one can’t add an association later in the game. Sometimes the Rails way is just KISS and adding the column by hand.

Related posts:

1. Adding AJAX Bookmarks to Your Rails Application (Part 1 of 2)

Ever since I started doing Capistrano deploys from my Mac, I have been seeing the following error:

zlib(finalizer): the stream was freed prematurely.

The error seems harmless, but I figure that errors are there for a reason and the Sysadmin in me decided to try to get rid of it. A quick Google for an answer said something about adding the following line of code to you Capfile (or in my case, I separated it out to my config/deploy.rb:

I couldn’t actually find the reason for this. But I guess finding the solution is good enough for now.

Related posts:

1. Email::Find
2. What is a DRD
3. Capistrano Hangs on Mac OS X Leopard

As I have spent the last few weeks/months learning Ruby and Rails, I have grown to love it more and more. The ease of use and the high learning curve make is fantastic for people like me who aren’t developers by nature.

I have recently come across a scenario in Rails that there is not yet a shortcut for. If you have a method that you want to execute in a few different callbacks, there is no shortcut for it. ie, I have the following:

I would like to be able to write this as:

This would obviously only work if the callbacks were then treated as arrays of functions and each time a callback was found in the model, the method was pushed onto the array.

Related posts:

1. Adding An Average Column To A Model
2. Testing Sessions with Digest::SHA256 Passwords In Rails
3. Adding AJAX Bookmarks to Your Rails Application (Part 1 of 2)