All about Rails - Home

Session Store Switching

2008-05-21T16:38:00Z

I wrote a short article about a little gotcha, and the solution to it when switching your rails session store. Check it out: http://rails.learnhub.com/lesson/page/1858-how-to-switch-your-default-session-store

How to convert your svn repo to git

2008-04-04T02:50:00Z

Everyone loves git (unless you love mecurial), and svn is so passe, so it's time to hop on the bandwagon!

Step 1: Install Git. I use macports.


# sudo port install git-core +svn

Others may want to use one of these commands:


# sudo apt-get install git-core
# yum install git-core
# emerge -av git
# sudo pkg_add -i git-svn  
# sudo pkg_add -r git

Step 2: Check out your svn project with git. This may take a while, my project took about 20 minutes and it has 1300+ commits.


# git-svn clone https://svn.yourhost.name/projectname projectname.git

Step 3: Get any commits that may have been made to your subversion repo while you were exporting it.


# git-svn rebase

Now you've got a functional git clone of your subversion repo. git commands are very similar to svn commands. For example:


# git commit -a -m "This is a commit message"
# git help  (to learn about more commands)

If you want to commit the changes you have made to your git repo to your svn repo, it's quite easy:


# git-svn dcommit

Calling partials through helpers

2008-04-03T15:52:00Z

Rails partials are are fragments of template code that can be inserted into a view. They can really simplify template code, by factoring out repeated code.

For example, I often put forms into a partial so that the form can be shared be create and edit views:

quizzes/new.html.haml


= error_messages_for :quiz
- form_for :quiz, @quiz, :url => quizzes_path, :html => {:method => :post} do |form|
  = render :partial => 'quizzes/form', :locals => {:form => form}
  = submit_tag 'Create'

quizzes/edit.html.haml


= error_messages_for :quiz
- form_for :quiz, @quiz, :url => quiz_path(@quiz), :html => {:method => :put} do |form|
  = render :partial => 'quizzes/form', :locals => {:form => form}
  = submit_tag 'Update'

Many (most) people put the render call directly in their templates. This is not a good idea! What if you want to change the template path, or conditionally render a different template in certain conditions? Now you've got to repeat yourself in both templates, and that's bad news.

A simple way to fix this is to *always* use a helper to render the partial. That way any changes can be made in one place, and it also a great place to store any messy conditional logic so that it doesn't clutter up your templates.

quizzes/new.html.haml


= error_messages_for :quiz
- form_for :quiz, @quiz, :url => quizzes_path, :html => {:method => :post} do |form|
  = quiz_form(form)
  = submit_tag 'Create'

quizzes/edit.html.haml


= error_messages_for :quiz
- form_for :quiz, @quiz, :url => quiz_path(@quiz), :html => {:method => :put} do |form|
  = quiz_form(form)
  = submit_tag 'Update'

quizzes_helper.rb

1234	def quiz_form(form) render :partial => 'quizzes/form', :locals => {:form => form}end

Now if I want to do something, like say render a different form depending on a user's preference, it's easy to do.

quizzes/new.html.haml


= error_messages_for :quiz
- form_for :quiz, @quiz, :url => quizzes_path, :html => {:method => :post} do |form|
  = quiz_form(form, current_user)
  = submit_tag 'Create'

quizzes_helper.rb


def quiz_form(form, user = nil)
   if(!user.nil? && user.wants_advanced_quizzes))
     render :partial => 'quizzes/advanced_form', :locals => {:form => form}
   else
     render :partial => 'quizzes/form', :locals => {:form => form}
   end
end

IE8 beta is out

2008-03-06T03:36:00Z

A lot of people were really optimistic when it was announced that IE 8 would render Acid2, something that Firefox2 can't even do (Firefox beta3 can however).

It was thought that Microsoft was finally catching up in terms of standards compliance with the other popular browsers. To bad that rendering Acid2 doesn't really mean that the browser is 'standards compliant'. It just means that it can render the subset of the standard that Acid2 tests. With the release of Acid3, it looks like Microsoft focused solely on rendering Acid2, not on the standards in general. IE8 scored a poor 17/100 on Acid3.

On the opposite end of the spectrum, Apple's latest Webkit beta scored 86/100.

Learnhub launches!

2008-03-04T17:35:00Z

The entire Savvica team has been busy since November building Learnhub, which we launched today at noon. We've had a great time building it, and have a ton of ideas for future features. Check it out!

A gotcha

2008-02-27T23:23:00Z

Just got bitten by this. Observers are not called when deleting an object via a through collection.

An example:


class Newsletter < ActiveRecord::Base
  has_many :subscribers
  has_many :users, :through => :subscribers
end

class SubscriberObserver <  ActiveRecord::Observer
  def after_destroy(subscriber)
    # do somethng
  end
end

# case 1
# deletes a subscriber object. after_destroy is not called
@newsletter.users.delete(user) 

# case 2
 # after_destroy is called.
subscriber = @newsletter.subscribers.find(:first, :conditions => ["user_id = ?", user.id])
subscriber.destroy unless subscriber.nil?

In both cases a subscriber object is being destroyed, but the observer is being called only in the second scenario. I'll have to look into patching this when I get a chance ....

One thing I hate about Rails ...

2008-02-26T21:08:00Z

One thing I truly hate in Rails is ActionMailer. It sucks.

First off (admittedly a minor point), mailers are stored in app/models, even though they are basically a pseudo controllers, complete with view templates (stored in app/views). It makes no sense.

Secondly, ActionMailer does not have access to named routes or any view helpers. The 'rails way' would be to call the mailer from a controller, passing the URL as an argument which is just stupid in my opinion. Most of the time I send an email in an application it is due to a change in an model's state, not due to a specific controller interaction. A nice way of doing this through use of active record observers (which also don't have access to routes).

This means I generally end up hardcoding the URLs in the mailer. It wouldn't be a huge deal if my test coverage checks that the hardcoded url in the email body matches a generated one. But to do that you'll need to write integration tests rather than the default 'ActionMailer' tests that are auto generated. The whole mess frustrates me unlike anything else in Rails.

Merb seems to get it right with its Merb::MailController. Perhaps something similar could be added to Rails via a plugin?

Immutable Attribute Plugin

2007-11-14T15:04:00Z

A new Ruby on Rails validation plugin that allows you to mark model attributes as immutable. Rails surprisingly does not include a validation method to make a model attribute immutable. (That is, the attribute can not be changed after it is set the first time.) I created this validation plugin to help that. Check out my post on the Savvica blog.

Updates and such ...

2007-11-03T22:17:00Z

I resigned my position with TSOT a few weeks ago, and have joined John and Malgosia at Savvica. We're going to be building some pretty cool stuff!

Last week Carsten and I were able to knock off a beta of Languify, which is a tool to help software developers to collect and manage language translations for software localization. It's pretty simple for now, but we've got a lot of cool ideas that we'll be implementing in the near future. Keep an eye on it!

Facebook Developer Garage Updates

2007-08-11T19:00:00Z

CityTV did a segment about the event
Craig Saila posted his slides about profile updates and about FLQ
Global Nerdy's notes

Rails on OpenBSD

2007-08-10T13:32:00Z

It's extremely easy.

Install your favorite database server. My favorite is Postgres.
$ sudo pkg_add -i postgresql-server
Install the ruby database bindings for your favorite database server.
$ sudo pkg_add -i ruby-postgres
Install rails.
$ sudo pkg_add -i ruby-rails

That's it!. pkg_add is a great tool (much like apt on debian systems) that takes care of all of the package dependancies.

haml & sass

2007-08-09T13:00:00Z

haml is template languages for Ruby on Rails. It's a plugin that provides an alternative to Rails' native view templating library erb. sass is included with haml, and provides templating for css files. Through clever usage of whitespace, both remove much of the verbosity of html and css (<>, end tags ,etc) , providing a concise way of creating templates. For example, take this typical layout template:


<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
       "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
  <meta http-equiv="content-type" content="text/html;charset=UTF-8" />
  <title><%= controller.action_name %></title>
  <%= stylesheet_link_tag 'mycss' %>
</head>
<body>
  <p style="color: green">
    <%= flash[:notice] %>
  </p>
  <div id="header">
     <h1>Header</h1>
  </div>
  <div id="content">
    <%= yield  %>
  </div>
</body>
</html>

Here's the same thing in haml. Notice the usage of whitespace to delimit block the nesting of the code. Also, regular html can be mixed in as well.


!!!
%html{:xmlns => "http://www.w3.org/1999/xhtml", "xml:lang" => "en", :lang => "en"}
  %head
    <meta http-equiv="content-type" content="text/html;charset=UTF-8" />
    %title= controller.action_name
    = stylesheet_link_tag 'mycss'
  %body
    %p{:style => "color:green"}= flash[:notice]
    #header
      %h1 Header
    #content
      = yield

There are a few benefits to this:

the information density is greater, so more of the template is visible on screen.
less characters to type, so less chance to make a typo
nesting is clearly visible, and no more issues with missing end tags.

sass is similar to haml in that it uses whitespace for nesting, eliminating verbosity. In my next article, I'll explain the benefits and usage of Sass.

Facebook Garage - Part 6

2007-08-08T00:49:00Z

Demo: Carpool by: Rajat Suri

Rajat explains how he produced the idea of Carpool, and how Facebook was the perfect (only?) platform to build it. Facebook already has the users, and it connects people that already trust each other (at least on some level).

The app is pretty cool, it shows rides offered and needed, how many miles the user has travelled, and how many CO2 emissions have been avoided by carpooling. Rajat should talk to Zero Footprint about this :)

Demo: My Aquarium by Greg Thomson

This developer's applications have a total of 2.6 million users and 75,000 new users per day. (wow!)

Greg talked about profile updates, which apparently have a failure rate of 5%. He solved the problem by having a queue that runs all of the time, attempting requests until they succeed.

Facebook Garage - Part 5

2007-08-08T00:19:00Z

Updating the Facebook Profile. by Colin Smillie

Rules:

content rules
- no iframes, or auto-running flash
display rules
- consistent presentation and user experience

Caching

The profile page is cached, so your app must notify facebook in order to update the profile page.
See the fb:ref method for updates.
multiple handles are possible, so you could update many profiles at once (think of a horrorscope application, only 12 updates would need to be made for many users

Application Demo: "My Free Stuff", by: Ricardo Covo

Ricardo presents his application which was developed with MS tools (dotNet + SQL Server). He also uses iframes, which seems to be less common. Like Rails, dotNet has an API wrapper (several) for ease of use.

Ricardo found the facebook platform to be extremely easy to develop for, and the api wrappers provide seamless integration into your own platform of choice.

Facebook Garage - Part 4

2007-08-08T00:17:00Z

FQL: Overview by Craig Saila

Facebook API calls are just embedded FQL calls.

Advanatages:

common syntac for all methods
condense facebook queries
reduce response size

FQL is very similar to SQL. Sub selects are allowed, etc.

Ex: SELECT current_location FROM user WHERE uid = 324324. This will return an XML response.

There are about two dozen tables that can be queried. The users table is most often queried.

FQL contains some helper functions that help with queries. It's quite PHP like.

You can only query against "indexable" columns in your where statement. You need at least one in your query.

FQL is designed to be efficient, so no JOIN, ORDER BY, GROUP BY or LIMIT. Each FROM can only reference one table. You must also specify each field that you want the query to return ("SELECT *" is not allowed). Sorting of data, etc must be done on the application level.

Tips:

Use the developers tools (fql.query)
Read the API docs
Share what you learn on your blog or wiki