Friday, November 7, 2008

Rails Guides

The Ruby on Rails team and many Rails enthuisiasts have been working hard on a new site for guides for Rails. They range from guides for getting started, to guides covering more of the specifics. The getting started guide covers a lot, but it can look a little length to the newcomer - perhaps it should be broken into sections. It does, though, cover each of the pieces and paradigms used in Rails, making learning the language fully rather easy. For example, it covers the Model View Controller paradigm used in Rails. Models are representations of the data we used, Views are displays of that data, and the Controller interacts with the user. Then it goes on to talk about all the pieces of rails, ranging from Active Record (for Models) through Active Support (for all the little things).

Wednesday, November 5, 2008

Rails Dynamic Links

Since I've been working on a program for Mindbridge for a while, (and you can see how busy I am), I try occasionally to post useful things I remember here. One is about Rails dynamic linking abilities. I recently forgot, then remembered again, about how easy it is to link to an object.

(%= link_to "View", @object %) instead of (%= link_to "View", object_path(@object) %)

You can use a handy REST cheat sheet to keep it all handy. It helps me remember that I have to explicitly declare the delete method, for example, in my links.

Tuesday, October 21, 2008

Rails Captcha

I just finished a lot of improvement on the custom Captcha implementation I use on all my websites. Right now the captcha protects comment forms and user profiles to prevent abuse by spammers, and it's very effective. Spammers obviously can't post spam without actually reading and interpreting my images as letters, or without having access to my MySQL database.

How It Works
The design for my custom captcha for rails is simple enough. Whenever the user request a page displaying a captcha-protected form, a captcha object is created in the database, which has a randomly generated private key, and I use it's id number as the public key. If the inputter does not submit the correct private key along with the public key (which is stored in a hidden value on the form), then they are given an error message. The user can see the private key, if they are a human, through a gif image which includes the letters A-L as part of the 5-digit key. The letters are blurred a little using a few RMagick functions and a few calls to random, and then the resulting image is given through rails in response to a .gif format request.

My improvements recently were rather simple. I first realized I had way too much code in the controller, and I moved most of it to methods in the Captcha.rb model method. Then I used a collect function and some loops to simplify things that were repeated, trying to follow along with DRY principals. Now I'm pretty sure that the program runs a little smoother and bugs will be easier to iron out.

Thursday, August 7, 2008

Rails Development and Hosting

Here are some great posts about rails development, hosting, hiring, etc:

Ruby on Rails Hosting
An overview of some Ruby on Rails development and hosting companies.
View more »

11 Tips on Hiring a Rails Developer
Tips include looking for people who have contributed to the community, and more.View more »

Hosting Rails
A very cheap hosting company that offers mongrel for as little as $10 per month.View more »

Friday, August 1, 2008

Custom 404 Pages - Rails 404 Status

Sometimes your application hits it where it doesn't know what to render. Perhaps your user tried to access so URL from memory and spelled it wrong. Maybe they tried /user/john instead of /users/john. Whatever happens, they'll be getting some sort of error. Fortunately for you, you can control this error without much work. Add this to the bottom of your routes.rb file.

map.connect '*path', :controller => 'application', :action => 'rescue_404' unless ::ActionController::Base.consider_all_requests_local

Then add to your application.rb

def rescue_404

def rescue_action_in_public(exception)
case exception
when CustomNotFoundError, ::ActionController::UnknownAction then
#render_with_layout "shared/error404", 404, "standard"
render :template => "shared/error404", :layout => "standard", :status => "404"
@message = exception
render :template => "shared/error", :layout => "standard", :status => "500"

def local_request?
return false

Sometimes you may want to throw a 404 yourself. For example if they go to /wiki/doesnotexist you can render your own page. Use something as simple as:

render :action => "something", :status => 404

or as simple as

render :file => "#{RAILS_ROOT}/public/404.html", :status => 404 and return

Monday, June 2, 2008

Scaffold versus Scaffold Resource

Scaffolding has always been the standard way to start a Ruby on Rails piece/component/controller, generating the standard files and paths based on the specified model name. More recently, though, scaffold now creates a RESTful version of these rails conventions. At one time it simply generated regular CRUD, and then scaffold_resource came along to create a REST-based controller, model, and views. Now scaffold does that, by creating the correct views, actions, and allowing Rails to respond to different types of requests (XML, HTML, etc), which make it more restful.

Thursday, May 15, 2008

Give it a REST

So recently I learned what REST really meant. Basically it's CRUD+. This means you have Create, Read, Update, Delete, and then add in Index, Edit, & New. For some reason this is a big deal... I just thought that was a regular ol rails feature. But rest also involves using a resources map to do things like this:

map.resources :newsstory

Which then gives you access to things like

REST Examples
You get all this after map.resources :object
Path for the form to create a new object -> new_object_path
Path to create new object -> object_path (:method => :post)
Path to edit object -> edit_object_path(@object)
Path to send the edit form (update object) -> object_path(@object) (:method => :put)
Path to view object -> object_path(@object)