paulsturgess.co.uk articles

Installing Capistrano on Ruby 1.8.6 – Abort Trap error

Occasionally when installing gems I'll get an abort trap failure message.

Often I've found this means the version of Ruby isn't compatible with the gem. Sometimes I'll strike lucky and they'll be another version of the gem that does work.

However, that isn't always the case and there are times when it's not the version of Ruby that's the problem. Specifically I've seen this happen when installing Capistrano on Ruby 1.8.6

The way round this is simply to install the Highline gem first. To be honest I can't remember how I figured this out but it works for me. Hope it saves someone out there some time if they hit the same problem.

How to retry a specific queue of failed Resque jobs

Resque has a very handy interface for managing the queue of jobs but it falls short when jobs fail.

In order to only retry a specific queue drop onto the command line and run the following...

jobs = Resque::Failure.all(0, X)

Where X is the total number of failed messages.

jobs.each_with_index {|j,i| Resque::Failure.requeue(i) if j["queue"] == "queue_name" }

It's important you loop around all the jobs, filtering inside the loop, as the requeue method relies on the index being accurate so it retries the correct job.

Note that as each job is retried it wont clear the failed job out. You'll know if the job is successful, however, if your failed jobs list doesn't grow.

Heroku H14 error (No Web Process running)

Recently I had this problem even though heroku ps said everything was up and running and I had one web worker running.

However, a quick turn it off and on again and everything was good:

heroku restart

Heroku have a detailed list of error codes and solutions that are well worth a look at.

How to write a ruby gem

Did you know you can use Bundler to create gems?

This guide aptly named 'Developing a RubyGem using Bundler' is quite comprehensive and well worth a read.

Additionally the guides on rubygems.org are great. The 'Make your own gem' in particular.

Any gems on rubygems.org are automatically documented online by YARD.

ActiveRecord::StatementInvalid Mysql::Error: Duplicate entry in Ruby on Rails

Sometimes users like to double click, sometimes requests just happen very, very, very close together. This can mean that Rails isn't quick enough to use the validations you have setup in your models to prevent duplicate entries getting into the database. I've found ajax requests are particularly vulnerable.

So like all good programmers the database is setup with unique indexes and the like to ensure that, regardless of the client connecting to the database, your data stays clean.

However, this can sometimes cause annoying Duplicate entry exceptions that actually, you don't really care about and you'd just wish your application silently captured them.

A few times now I've implemented code like this...

begin
  SomeObject.create(...)
rescue ActiveRecord::StatementInvalid => e
  raise e unless /#{DUPLICATE_ENTRY_ERROR}/.match(e)
end

Then in an intializer I have...

DUPLICATE_ENTRY_ERROR = "Mysql::Error: Duplicate entry"

I don't like it but it does work. Another option could be to use javascript to disable form buttons after the initial submit but this felt like a more 'fool proof' method.

I'm all up for hearing any alternative suggestions, so if you know a better solution please leave a comment.

How to remove a specific version of a gem file in a specific directory

First find the path of the gem...

gem list -d "name_of_gem"

Then to remove the gem...

gem uninstall 'name_of_gem' -i '/path/to/gem'

Ruby on Rails to_sym ArgumentError: interning empty string on startup

Recently when I deployed a Rails application onto the staging server I got a Passenger error page telling me the application wouldn't start. The full error was:

/var/lib/gems/1.8/gems/actionpack-2.3.5/lib/action_view/template.rb:226:in `to_sym':ArgumentError: interning empty string

Essentially it's saying you can't call to_sym on an empty string. Unfortunately no great clues as to why this might be happening.

Looking at the backtrace revealed the source of issue was triggered by the valid_locale? method in Action View.

Such is the beauty of Rails I've never really had the need to delve into this method before to see what's going on. However, after a bit of digging I could see that Rails checks all the extensions of the view files to determine the language. Clever.

So I stuck in a simple rescue around the method call and output the full path of the file it was running this method on. This revealed the problem, a file had been checked into the repository, unknown to me, that had a filename in the format:

foo..html.erb

I removed the extra period and everything worked. I hope this saves someone out there the time I wasted hunting this down!

Autocomplete text input using unobtrusive jQuery in Ruby on Rails

Recently I needed to implement an autocomplete feature into a Ruby on Rails application so I thought I'd throw up the bare-bones of what I came up with as a simple example.

Note that it written unobtrusively using jQuery, but as it was for an admin system there is no non-javascript fall back.

So for my example we have groups and in those groups we have multiple users (joined by a group_users table). I want to be able to create a group and add all the users on one screen, using autocomplete to find the users.

The models...

class Group < ActiveRecord::Base
  has_many :group_users, :dependent => :destroy
  has_many :users, :through => :group_users
end

class GroupUser < ActiveRecord::Base
  belongs_to :group
  belongs_to :user
end

class User < ActiveRecord::Base
  has_many :group_users
  has_many :groups, :through => :group_users
  
  named_scope :autocomplete_name, lambda{ |name| {:include => :user, :conditions => ["users.name LIKE ?", "#{name}%"]} }
end

The groups controller will be restful with just a couple of extra instance variables to load up the users. I'm only going to include the creation methods here...

class GroupsController < ApplicationController

  def new
    @group = Group.new
    @users = @group.users
    respond_to do |format|
      format.html 
      format.xml  { render :xml => @group }
    end
  end

  def create
    @group = Group.new(params[:group])
    @users = @group.users
    respond_to do |format|
      if @group.save
        flash[:notice] = 'Group was successfully created.'
        format.html { redirect_to(@group) }
        format.xml  { render :xml => @group, :status => :created, :location => @group }
      else
        format.html { render :action => "new" }
        format.xml  { render :xml => @group.errors, :status => :unprocessable_entity }
      end
    end
  end
  
end

In the users controller setup a couple of custom actions that will be called via ajax.

class UsersController < ApplicationController

  def load_user
    render :partial => "/users/details", :locals => {:user => User.find(params[:id])}
  end

  def autocomplete
    render :json => User.autocomplete_name(params[:term]).collect{ |user| {:value => user.id, :label => "#{user.name}"} }
  end
end

load_user is called once you have selected the user you want from the autocomplete suggestions. autocomplete does the searching for users based on the text the user enters. The json returned is digested by the javascript.

Routes will be as per normal except you'll need to update the users like so...

ActionController::Routing::Routes.draw do |map|
  map.resources :users, :collection => {:load_user => :get, :autocomplete => :get}
end

Now in groups/new .erb file you'll need...

<h1>New group</h1>

<%= error_messages_for :group %>
<% form_for(@group) do |f| %>
  
  <%= f.label :name, "Group name" %>
  <%= f.text_field :name %>

  <div>
    <label for="user_name">Add new user</label>
    <%= text_field_tag "user_name", nil, :class => "text", :id => "user_name" %>
  </div>

  <fieldset class="data_container">
    <% users.each do |user| %>
      <%= render "/users/details", :user => user %>
    <% end %>
  </fieldset>
  
  <%= submit_tag %>
  
<% end %>

So the gorup has a name attribute and below that is the autocompelte text input for searching for users. Below that we render out all the user details attached to the group, in reality i've split these fields into a partial where they are re-used in the edit action.

The users/details partial looks like this...

<div class="user_details">
  <h2><%= user.name %></h2>
  <dl>
    <dt>Address</dt>
    <dd><%= user.address %></dd>
    <dt>Telephone</dt>
    <dd><%= user.telephone %></dd>
  </dl>
  <%= hidden_field_tag "group[user_ids][]", user.id %>
  <%= content_tag(:p, link_to("Remove user", "#", :class => "remove_user")) %>
</div>

This partial is rendered whenever you select a user. The user attributes you output are not important, the key is the hidden field containing the user id. By passing this through in the form rails will automagically create all the group_member join records required to link the users to the group. No additional controller code is required.

In your javascript file add the following. Note that you will need jQuery UI 1.8

$(function() {
  $("#new_group, #edit_group").autocompleteUserName();  
});

$.fn.autocompleteUserName = function(){
  return this.each(function(){
    var input = $("#user_name", this);
    var dataContainer = $('.data_container',this);
    
    var loadData = function(item){
      if(item){
        var user_id = item.value;
        $.get("/users/load_user", {id:user_id}, function(data){
          if(data){ dataContainer.html(data); }
        });
      }
    }
    
    input.initAutocomplete(loadData, "/users/autocomplete");
    
    // remove links
    dataContainer.delegate('.remove_user','click',function(){
      $(this).closest('.user_details').remove();
      return false;
    });
  });
};


$.fn.initAutocomplete = function(callback, source){
  return this.each(function(){
    var input = $(this);
    input.autocomplete({
      source: source,
      minLength: 2, //user must type at least 2 characters
      select: function(event, ui) {
        if(ui.item){ 
          input.val(ui.item.label); 
          callback(ui.item);
        }
        return false;
      },
      focus: function(event, ui) { // triggered by keyboard selection
        if(ui.item){ input.val(ui.item.label); }
        return false;
      },
      change: function(event, ui) { // called after the menu closes
        if(callback){ input.val(""); }
      } 
    });
  });
}

So the autocompleteUserName function takes the user search string, sets up an ajax callback called loadData that will load the html onto the page and then calls the initAutocomplete function. This function uses the autocomplete functionality built into jQuery. Take a look at the jquery api to see how the autocomplete box behaviour can be tweaked.

I've split initAutocomplete out into its' own function so that I can have multiple autocomplete boxes that load different data.

I've also included a small amount of code in the autocompleteUserName function to allow for the removal of users from the group.

Below are some CSS styles are taken from the jQuery api and tweaked so they should provide a decent starting point...

.ui-autocomplete { position: absolute; cursor: default; }	
* html .ui-autocomplete { width:1px; } /* without this, the menu expands to 100% in IE6 */
.ui-menu {
	list-style:none;
	padding: 0px;
	margin: 0;
	display:block;
	float: left;
	border:1px solid #494849;
}
.ui-menu .ui-menu-item {
	margin:0;
	padding: 0;
	zoom: 1;
	float: left;
	clear: left;
	width: 100%;
	text-align:left;
}
.ui-menu .ui-menu-item a {
	text-decoration:none;
	display:block;
	line-height:1.4;
	zoom:1;
	background:#FFF;
  padding:5px;
}
.ui-menu .ui-menu-item a.ui-state-hover,
.ui-menu .ui-menu-item a.ui-state-active {
	font-weight: normal;
	background:#717171;
  color:#FFF;
  text-decoration:none;
}

Hope this helps someone out there!

Using Polymorphic urls and paths to create dynamic routes in Ruby on Rails

Dynamic named routes in Ruby on Rails are really useful when you want to generate a url but you don't necessarily know which records it will be for. For example if have a controller action that is used for multiple views in your application. A simple example would be where you have articles, comments and users...

Class Article < ActiveRecord::Base
  has_many :comments
end

Class User < ActiveRecord::Base
  has_many :comments
end

Class Comment < ActiveRecord::Base
  belongs_to :user
  belongs_to :article
end

Now you might have a controller for the comments with an index action that could be used in two ways. Firstly to load the comments for a particular article or secondly to load the comments for a particular user. Let's say you have the following in your routes.rb

ActionController::Routing::Routes.draw do |map|
  map.resources :articles do |article|
    article.resources :comments
  end
  map.resources :users do |user|
    user.resources :comments
  end
end

So now you have two routes to get to each action in the comments controller. For example the edit action...

edit_article_comment GET    /articles/:article_id/comments/:id/edit(.:format) {:action=>"edit", :controller=>"comments"}

edit_user_comment GET    /users/:user_id/comments/:id/edit(.:format) {:action=>"edit", :controller=>"comments"}

So now let's say that on the index action where you list the comments you have an edit link. This is where the polymorphic_url comes in handy to dynamically create url for the correct route.

edit_polymorphic_url([(@article || @user), comment])

Which will result in either edit_article_comment_url or edit_user_comment_url depending on which instance variable is present. Note that there is also new_polymorphic_url and just polymorphic_url The Rails api documentation is well worth a look. Interesting to note that Rails uses polymorphic_url in redirect_to and form_for.

Using rspec to test a named_scope in Ruby on Rails

When testing a named_scope it's important to test the expected behaviour of the method, not how it's implemented, as this will allow you to re-factor your code using the test as an indicator that the re-factor was successful.

So in your model you might have...

class User < ActiveRecord::Base
    named_scope :active, :conditions => ["active = ?", true]
end

In your model spec I'd then have...

describe User, "::active" do
    it "includes users that are active" do
        @user = Factory(:user, :active => true)
        User.active.should include(@user)
    end

    it "excludes users that are not active" do
        @user = Factory(:user, :active => false)
        User.active.should_not include(@user)
    end
end

The key thing here is that we're not actually calling named_scope, we could change the method to be a regular class method if we wanted and the test would still pass.

It may be a good idea to check that the model has the method defined like so...

User.should respond_to(:active)