When browsing around today I saw quite a few sites talking about the Rails Best Practices presentation / talk that ihower did at the Kungfu RailsConf. Check it below, it really covers a lot of basic tips on how to clean up your code and follow some better coding practices.

Someone just released a gem that will analyze your code and check for “Best Practices” -  seems promising. Check it out at GitHub here: http://github.com/flyerhzm/rails_best_practices

Just a quick tip for when you are doing nested resources….

In this example, I am building a app for a client where there is a recipient and they have many physicians. So I have a case where I have a nested resource. To keep thing DRY, I added this to my before filter where I get the recipient. This allows you to nuke the find in the show, edit, update and delete actions and retain the original use of @physician.

def get_recipient
  @recipient = Recipient.find(params[:recipient_id])
  # DRYs her up a little so you don't have a find in the show,edit,update and delete actions
  @physician = @recipient.physicians.find(params[:id]) if params[:id]
end

Don’t forget to modify your index find, change it to reflect the nested route… In my case:

    @physicians = @recipient.physicians.find(:all)

Have any other useful tips? Let me know!

Put together a small list of apps I saw today that are part of the Rails Rumble 2008.

Let me know if I missed any by adding a comment.  Check out http://blog.railsrumble.com/ – I am sure they will post an official list shortly.

*** The list keeps growing!

http://meetinbetween.us/ – Car pooling site

http://tunemuncher.com/ – Music artist tracking site, shows latest ablums from artists you like.

http://wurbe.r08.railsrumble.com/ – Conference organization?

http://foodferret.com/ – A service that finds the right food for you?

http://likis.r08.railsrumble.com/ – Social language learning

http://chicago.r08.railsrumble.com/ – Simple presentations

http://so2speak.net – RSS / Webservices to speach

http://wethepeople.r08.railsrumble.com/ – Political news?

http://myideadrawer.r08.railsrumble.com/ - Organize, collect, and share your projects

http://pug.r08.railsrumble.com/ – Pickup game locator

http://a8.r08.railsrumble.com/ – A solution for managing projects from proposal, through build stage, to getting paid.

http://dontsendit.r08.railsrumble.com/ – Delayed email sending?

http://maestro.r08.railsrumble.com/ – Music Create / Sharing app

http://notifly.r08.railsrumble.com/ - Easily integrate communication services into your app

http://jotlyapp.com/ – Blogging app

http://run1mile.com – A program to get your from nothing to running one mile

http://iheartgames.r08.railsrumble.com/ – A social application where you list your games and connect with your friends to play games.

http://billelle.r08.railsrumble.com – Unknown

http://greatminds.r08.railsrumble.com/ – A co-operative word game for two or more players

http://www.loveloathe.com/ – Lists of things you love and hate.

http://poolr.r08.railsrumble.com/ – Find a car pool

http://sellyourattention.r08.railsrumble.com/ – Build a potato man

http://gtd.r08.railsrumble.com/ –  task / GTD app

http://twalala.com – Web based twitter client

http://hikedit.r08.railsrumble.com/ – Hiking fan site, find trails

http://stickyboard.r08.railsrumble.com/ – No idea what this is – a wall of randomness?

http://milliontagcloud.r08.railsrumble.com/ – donation app

http://osc.r08.railsrumble.com/ – Treasuring hunting w/SMS

http://foodistic.com – Track what you eat

http://www.playubetcha.com/ - online game where you can wager points on real-world events

http://storyseed.r08.railsrumble.com/ – create, publish, read and rate stories

http://citenow.r08.railsrumble.com/ – Keeps track of your citations on books, journals and websites.

http://rio.r08.railsrumble.com/ – pics of your diet (food)

http://goodbad.me/ - see all the good and bad stuff in the Twitterverse

http://inspiresme.r08.railsrumble.com/home -  say who inspirse you

http://pranziamo.r08.railsrumble.com/ - Lunch recommendations

http://diedebtdie.r08.railsrumble.com/ – provides you with tools and motivation to get you out of the red…and back in the black.

http://qflip.r08.railsrumble.com/ – Qflip is an app that integrates with the netflix api that helps people to rent randomly.

http://couldya.r08.railsrumble.com/ – Its a way to get help with things using your social network.

http://ir.r08.railsrumble.com/ -Latte Art with ratings

http://ideasftw.com – An idea incubator.

http://sheepfit.r08.railsrumble.com/ – a stretch reminder

http://www.rubyreddo.com – RubyReddo is a service to translate your GetText .po files

http://justafinlist.r08.railsrumble.com/ – Just A F***ing List

http://dense.r08.railsrumble.com/ – Dense is a simple slideshop app

http://remindr.info – Effortless one-click reminder about pretty much anything

http://ostraka.r08.railsrumble.com/ – Ostraka is the digital counterpart of ancient democratic instrument of ostracism.

http://tagueame.r08.railsrumble.com/ – Tagueame is a little experiment about socializing online opinions about your friends and family.

http://a8.r08.railsrumble.com/ – A business related app for project management, time reporting, invoicing with built in chat rooms.

http://wheresthemilkat.r08.railsrumble.com/ – find out who’s got the best prices, and where they are

http://ndebted.com – A service for tracking and sharing debts with friends

http://assassin.r08.railsrumble.com – The assassin game

Another great list of Rails Rumble 2008 apps  – > http://48hrlaunch.wordpress.com/2008/10/20/rails-rumble-2008-apps/

http://revealthebias.r08.railsrumble.com/ – Reveal the Bias

Just an FYI…

Rails Rumble 2008 has started. I am signed up to be a judge, It would be pretty interesting to see what comes out of this 48 hour hack fest.

The Rails Rumble is a 48 hour web application development competition. As a contestant, you get one weekend to design, develop, and deploy the best web property that you can, using the awesome power of Ruby on Rails

Read more about it from their latest blog post: It’s On!

I’ll try to get a list going of the open source projects that come out of this event, and post the git hub links.

Here is the first app from what someone had posted in IRC: http://gentrify.r08.railsrumble.com/ - maybe its something to follow?

**** Update

Links to watch:

http://www.trackclass.com

http://gentrify.r08.railsrumble.com/

http://li47-127.members.linode.com/

http://tweetfu.r08.railsrumble.com/

http://chores.r08.railsrumble.com/

http://laktek.r08.railsrumble.com/

http://justafinlist.r08.railsrumble.com/

http://confreader.r08.railsrumble.com/

http://sheepfit.r08.railsrumble.com/

This tutorial is an extension of the paperclip tutorial I put up last week. This time we are going to take advantage of polymorphic paperclip. Polymorphic paperclip utilizes separate tables (an assets table and an attachings table) to track your attachments. This allows for an unlimited number of attachments per item per model. In the first tutorial I showed you how to attach just one item, although you could add more columns to your table to handle additional attachments this way is a lot more flexible. While this plugin is not perfect, there is a lot of room for improvement, its a great starting point. Perhaps a fork is on its way from me…

Project Page: http://github.com/heavysixer/paperclippolymorph/tree/master

First things first, lets install the plugin:

script/plugin git://github.com/heavysixer/paperclippolymorph.git

Lets setup our new migration that is needed. After reading the rdoc, I noticed there was a new generator installed. Great, this makes things even easier. Lets verify that the generator is available for use, first run:

script/generate

This should produce a list of all generators available for use, my list below might vary from yours depending upon what plugins you have installed…

Installed Generators
  Plugins (vendor/plugins): authenticated, forgot_password, open_id_authentication_tables, paperclip, polymorphic_paperclip, roles, rspec, rspec_controller, rspec_model, rspec_scaffold, upgrade_open_id_authentication_tables
  Builtin: controller, integration_test, mailer, migration, model, observer, plugin, resource, scaffold, session_migration

As you will notice there is a polymorphic_paperclip generator, go ahead an run it as follows:

script/generate polymorphic_paperclip

Before you go and run rake db:migrate, open up the migration and modify the assets_count to attachings_count – it seems there is a minor bug. I notified the author of the plugin and will submit a patch via git. Now its OK to run rake db:migrate

Now we have the migration generated and the tables have been added to your database. Next we have to add (or change if you already have paperclip setup) the model where you want to have attachments by adding acts_as_polymorphic_paperclip. As an example, I posted my documents model below.

class Document < ActiveRecord::Base
# Document Belongs To A User
belongs_to :user
# for paperclip (polymorphic)
acts_as_polymorphic_paperclip 
# Validations
...

Note: Ideally I would like to be able to override the styles settings that are set in the plugins assets.rb, however I went ahead and hard coded them there to fit my needs. Example:

class Asset < ActiveRecord::Base
  has_many :attachings, :dependent => :destroy
  has_attached_file :data,
                    :styles => {
                    :thumb=> "100x100#",
                    :small  => "150x150>",
                    :medium => "300x300>",
                    :large =>   "500x500>",
                    :xlarge =>   "600x600>",
                    :xxlarge =>   "800x800>" }

For now, lets move onto the views where you are going to allow attachments. We are just going to have one upload, perhaps in another tutorial we will look at handling multiple uploads.

You need to make sure you put the html => { :multipart => true } in both your edit and new views for the model you are working with. Example in my case:

<% form_for(@document,:html => { :multipart => true }) do |f| %>
  <%= f.error_messages %>
  <%= render :partial => 'form', :locals => { :f => f } %>
<% end %>

Next you need to add the file upload field to your _form or edit/new views.

<p>
  Attach a file or image <br />
  <%= f.file_field :data%>
</p>

Now lets go ahead and make these attachments viewable in the document. For the edit view I added the following:

<p><%= image_tag asset.url(:medium) %></p>
<p>Tiny:  <%= asset.url(:tiny) %><br />
 Small:  <%= asset.url(:small)%><br />
 Medium:  <%= asset.url(:medium)%><br />
 Large:  <%= asset.url(:large)%><br />
 XL:  <%= asset.url(:xlarge)%><br />
 XXL:  <%= asset.url(:xxlarge)%><br />   
 Original:  <%= asset.url %>
</p>

Other Notes:

You can use this to attach an attachment if you were going to use a different view, for example an upload view with @document.assets.attach(@asset)

You can nuke an attachment by either calling @document.assets.detach or @document.assets.detach(@asset) depending upon how you are going about dealing with removing attachments. @document.assets.detach will nuke ALL attachments associated with that document, @document.essay.assets.detach(@asset) will nuke just that asset you are referencing.

Acts As Taggable On Steroids is a great plugin for Rails that makes adding tags to your application quick and easy. Check it out on github here => http://github.com/mattetti/acts_as_taggable_on_steroids/tree/master

I threw this post together with some notes that I took along the way when setting up the plugin for use.

Installation:

script/plugin install http://svn.viney.net.nz/things/rails/plugins/acts_as_taggable_on_steroids

Setup

Setup your migration by running the below:

ruby script/generate acts_as_taggable_migration
rake db:migrate

Add the acts_as_taggable to your model, in my case its the Events model…

class Event < ActiveRecord::Base
# acts as taggable on roids
acts_as_taggable

Now I needed to add a way to allow tags to be added to Events, in my form for my Event I added the following:

<p>
  <%= f.label 'Tag List (Delimiter = ,)' %><br />
  <%= f.text_field :tag_list %>
</p>

To view the tags associated this a Event on the Show page, along with linking to the actual tag to search for other events tagged with the same item, I added the following:

<p><strong>This event was tagged with</strong>: <% for tag in @event.tags %> 
<%= link_to tag.name, events_path(:view =>'tag', :tag => tag.name) %><% end %>
</p>

Tag Clouds

In order to use the plugin’s build in tag cloud functionality you need to add the helper to your application helper by doing the following:

  module ApplicationHelper
    include TagsHelper
  end

In your controller where you are planning on using your tag cloud add the below, this will grab the counts of all your tags so the helper can generate your cloud. Again in my case I am putting this in my Events controller.

@tags = Event.tag_counts

Now you use the following where you wish to show your views:

<% tag_cloud @tags, %w(tag1 tag2 tag3 tag4) do |tag, css_class| %>
    <%= link_to tag.name, { :action => :tag, :id => tag.name }, :class => css_class %>
  <% end %>

In your main CSS file you should add something to match the tags we specified above, this sets your font sizes for the cloud display generated by the helper…

  .tag1 { font-size: 1.0em; }
  .tag2 { font-size: 1.6em; }
  .tag3 { font-size: 2.7em; }
  .tag4 { font-size: 3.8em; }

Tag Clouds with Paginate Example

Here I am passing the page and tag to my events model to find all events tagged with that tag, and then use the results of that query and passing it onto paginate.

def self.tag_event_list(page, tag)
 
 options = Event.find_options_for_find_tagged_with(tag).merge :page => page, :per_page => 10, :order => 'date DESC' 
 paginate(options)
 
end

Other Notes:

I added the following to my environment.rb file so that the unused tags get destroyed if they are no longer in use by any events.

# automatically remove dead tags
Tag.destroy_unused = true

For more help check out the read me here: http://github.com/mattetti/acts_as_taggable_on_steroids/tree/master

I used Paperclip for my latest project, and I figured I would give a brief tutorial on how to use it.

Paperclip – Paperclip is intended as an easy file attachment library for ActiveRecord. The intent behind it was to keep setup as easy as possible and to treat files as much like other attributes as possible. http://github.com/thoughtbot/paperclip/tree/master

In my case, I wanted to allow an attachment to an Event, which will have one photo.

To install:

script/plugin install git://github.com/thoughtbot/paperclip.git

Create your migration, again in my case I was adding the images to my Events model / DB, so I did the following:

script/generate migration AddPhotosToEvents

Open up your newly created migration with your favorite Text editor, and add the following:

class AddPhotoToEvent < ActiveRecord::Migration
  def self.up
    add_column :events, :photo_file_name, :string
    add_column :events, :photo_content_type, :string
    add_column :events, :photo_file_size, :integer
  end
 
  def self.down
    remove_column :events, :photo_file_name
    remove_column :events, :photo_content_type
    remove_column :events, :photo_file_size
  end
end

Then rake your migration so the new columns are added to your database:

rake db:migrate

Next you need to tell your model to use Paperclip, again I am using the Event model as an example, the #Paperclip and below is what you need to add. If you notice below I added 4 options to the :styles. I wanted to have a few different sizes generated when a image was uploaded, i named them appropriately (you can name them whatever you wish). Please note when you put a # on the end it signifies that you want that exact aspect ratio, it will crop your photo automatically. When you use > on the end it will make the largest side the size you specify and keep the aspect ratio uploaded. In addition note that because we specified has_attached_file :photo its going to look for that naming convention we created in the migration above. In addition it uses that name to store your photo in the public folder of your application. So our photo url is going to be as follows: /public/photos/(event#)/(size_name)/image_name

class Event < ActiveRecord::Base
belongs_to :user
validates_presence_of :title, :on => :create, :message => "can't be blank"
validates_presence_of :teaser, :on => :create, :message => "can't be blank"
validates_presence_of :subject, :on => :create, :message => "can't be blank"
# Paperclip
has_attached_file :photo,
  :styles => {
    :thumb=> "100x100#",
    :small  => "150x150>",
    :medium => "300x300>",
    :large =>   "400x400>" }

Next you need to make sure you put the html => { :multipart => true } in both your edit and new views for the model you are working with. Example in my case:

<% form_for(@event,:html => { :multipart => true }) do |f| %>
  <%= f.error_messages %>
  <%= render :partial => 'form', :locals => { :f => f } %>
<% end %>

You then need to add the file_field to your new and edit forms or your _form partial like in my case:

<p>
  <%= f.label 'Photo' %><br />
  <%= f.file_field :photo %>
</p>

Next up is deciding on how you are going to use / view your images. In my case I wanted to show a few different sizes in the Event view. I also wanted to make sure I am only going to show photo’s if one exists. In this example I am just showing the small and medium sizes we generated:

<% if @event.photo.exists? then %>
<p>Small:<%= image_tag @event.photo.url(:small) %></p>
<p>Medium:<%= image_tag @event.photo.url(:medium) %></p>
<% else %>
<p> There are no photo's attached, upload one. </p>
<% end %>

A few other notes…

Calling @event.photo.nil destroys the photo

Also checkout this great tutorial Jim put up here.

Thats all for now, I’ll try to post an update with some more options / features when using the Paperclip plugin in the future.

*** Checkout my other tutorial on polymorphic paperclip if you would like to have multiple image attachments.

I am currently working on an interesting project for a customer of mine.   Hopefully I’ll be able to share more of the details with you all when the project is near completion.  The project involves creating events, parsing and caching RSS feeds, generating RSS feeds, as well as Emailing and SMS’ing subscribers daily events.   I have been working on the project for the last 5 days, and I am about one third of the way through.

I wanted to share some great plugins for Ruby on Rails that I have come across, along with some tutorials. Check back for an updated post with more info.

Plugins:

Restful Authentication - This widely-used plugin provides a foundation for securely managing user authentication – http://github.com/technoweenie/restful-authentication/tree/master

acts_as_taggable_on_steroids – This plugin is based on acts_as_taggable by DHH but includes extrassuch as tests, smarter tag assignment, and tag cloud calculations.  – http://github.com/mattetti/acts_as_taggable_on_steroids/tree/master

Paperclip – Paperclip is intended as an easy file attachment library for ActiveRecord. The intent behind it was to keep setup as easy as possible and to treat files as much like other attributes as possible. http://github.com/thoughtbot/paperclip/tree/master

Paperclip Polymorph – This plugin allows users of the Paperclip plugin to easily share attached files between multiple models. http://locusfoc.us/2008/6/29/paperclip-polymorph

acts_as_textiled - This simple plugin allows you to forget about constantly rendering Textile in your application. Instead, you can rest easy knowing the Textile fields you want to display as HTML will always be displayed as HTML (unless you tell your code otherwise). http://github.com/defunkt/acts_as_textiled/tree/master

Will_paginate – Pagination is just limiting the number of records displayed. Why should you let it get in your way while developing, then? This plugin makes magic happen. http://github.com/mislav/will_paginate/tree/master

Tutorials / Guides:

If you are new to Ruby on Rails be sure to check out the guides that are being worked on right now here: http://guides.rails.info/index.html

Railscasts – Free Ruby on Rails Screencasts – http://railscasts.com/

Learning Rails – Audio (Podcasts) and Screencasts - http://www.buildingwebapps.com/podcasts

Jim created a great list of plugins he found useful when he was building a social network in Rails. Check it out here: http://jimneath.org/2008/04/25/building-a-social-network-site-in-rails/

After playing with streamlined, I discovered ActiveScaffold. ActiveScaffold seems to be a bit more fine tuned and ready for production use then streamlined when it comes to restful development. This is just what I was looking for the speed up the dev of the backend admin area. While its not a final solution, it allows you to get things going fast and start coding the core of your app without the need to code all the minor crud features in the beginning. Its worth a look at, try the demo here: http://demo.activescaffold.com/users

ActiveScaffold also allows you to override anything you need, layouts, columns, associations, etc.
It doesn’t get more simple and clean then that.

Main features:

* An AJAXified table interface for creating, updating, and deleting objects
* Automatic handling of ActiveRecord associations
* Sorting, Search and Pagination
* Graceful JavaScript degradation
* RESTful API support (XML/YAML/JSON) baked in
* Sexy CSS styling and theming support
* More extension points than you can shake a stick at
* Guaranteed to work on Firefox 1+, IE 6+ and Safari 2+
* Released under the MIT License, the same one as Rails itself, so you can use it freely in your commercial applications.

This has always been something I was thinking of, why caint I create my project initially with edge rails?

There are always minor changes in edge rails that can effect creating your project from using the stable version. Using the way below eliminates that issue by creating your initial project with edge.

mkdir -p new_project/vendor
cd new_project
svn co http://svn.rubyonrails.org/rails/trunk vendor/rails
ruby vendor/rails/railties/bin/rails .

Now you have yourself a fresh project base to start your new edge rails app.