Basically I’ve coded two classes to be inherited by the controllers.

The first one is the base for all admin controllers:

#app/controllers/admin/base_controller.rb
class Admin::BaseController < ApplicationController
  before_filter :authenticate_user! #devise filter
  layout "admin"
end

It can be used to set up the behavior of all admin controllers as authentication. For instance the dashboard controller:

#app/controllers/admin/dashboard_controller.rb
class Admin::DashboardController < Admin::BaseController
  def index; end
end

The next class inherits from Admin::BaseController and it uses the method inherit_resources to include the features of Inherited Resources and overrides the method collection to support pagination (will_paginate).

#app/controllers/admin/resources_controller.rb
class Admin::ResourcesController < Admin::BaseController
  inherit_resources
  protected
  def collection
    get_collection_ivar || set_collection_ivar(end_of_association_chain.paginate(:page => params[:page], :per_page => per_page))
  end

  def per_page
    20
  end
end

As a result of that, the controllers for resources has became very simple:

#app/controllers/admin/pictures_controller.rb
class Admin::PicturesController < Admin::ResourcesController
  belongs_to :gallery
end

The above is better than:

#app/controllers/admin/pictures_controller.rb
class Admin::PicturesController < ApplicationController
  layout "admin"
  before_filter :authenticate_user!
  before_filter :load_gallery
  def index
    @pictures = @gallery.pictures.paginate(:page => params[:page], :per_page => 20)
    #(...)
  end
  #(...) new, edit, update, create and destroy...
  private
  def load_gallery
    @gallery = Gallery.find(params[:gallery_id])
  end
end

Right?

Some controllers would have just 1 line:

#app/controllers/admin/galleries_controller.rb
class Admin::GalleriesController < Admin::ResourcesController; end

That is all.

For more information about inherit_resources:

• Railscast episode 230
• Akita’s screencast
• Plataformatec Blog

Thanks to Bruno Miranda for the English text revisions. Photo by mattieb

• asynchronous upload to s3
• delaying the thumbnail generation
• anonymous photos
• saving photo dimensions

If you are using paperclip, some of the following recipes may be useful for you.

About Paperclip and Installation

Paperclip is a file upload plugin for Rails created by the thoughtbot (same guys who created shoulda and factory_girl). Paperclip is very active in github. Let it be known that it is the forth or fifth file upload plugin that I’ve already used and the best one so far IMHO.

Its installation is simple. In your config/environment.rb, add:

config.gem 'paperclip', :source => 'http://gemcutter.org'

Those using old paperclip versions may not have noticed it can be installed as a gem now (what is recommended by its developers).

Basic usage

If you just want to save a file in the file system:

class User < ActiveRecord::Base
    has_attached_file :avatar, :styles => { :medium => "120x120>", :thumb => "80x80>" }
 end

and for s3 storage (with a thumbnail):

class User < ActiveRecord::Base
  has_attached_file :avatar, :storage => :s3,
    :styles => { :medium => "120x120>", :thumb => "80x80>" },
    :s3_credentials => "#{RAILS_ROOT}/config/amazon_s3.yml",
    :bucket => "papertest",
    :path => ":class/:id/:basename_:style.:extension"
end

That’s it! If you need to improve the users’ experience and don’t want make them wait for: (1)the thumbnail generation and (2)the upload to s3 after they already have waited (3)the upload to your server, a bit more code will be necessary.

Asynchronous upload to s3

This recipe uses the gem delayed_job which can be easily replaced by other background job solution such as workling or a rake task + a cron job. If you don’t know delayed_job, there is a nice railscast about it. Assuming you have delayed_job installed, let’s start our example:

class User < ActiveRecord::Base
    has_attached_file :local_avatar, :styles => { :medium => "120x120>", :thumb => "80x80>" }
    has_attached_file :remote_avatar, :storage => :s3,
      :styles => { :medium => "120x120>", :thumb => "80x80>" },
      :s3_credentials => "#{RAILS_ROOT}/config/amazon_s3.yml",
      :bucket => "papertest",
      :path => ":class/:id/:basename_:style.:extension"
 end

The basic idea is to upload to the filesystem(local_avatar) and in background to upload to s3(remote_avatar). In the form there will be something like this:

<%= f.file_field :local_avatar %>

Nothing new so far. Now we’ll use a ActiveRecord callback to schedule the upload to s3:

after_save :queue_upload_to_s3
def queue_upload_to_s3
  send_later(:upload_to_s3) if self.local_avatar_updated_at_changed?
end
def upload_to_s3
  self.remote_avatar = local_avatar.to_file
  self.save!
end

And if you don’t want to keep a local copy, just change this method:

def upload_to_s3
  self.remote_avatar = local_avatar.to_file
  self.local_avatar = nil
  self.save!
end

Another tip it’s to create an alias to forget that you are working with two attachments:

alias_method :avatar=, :local_avatar=
def avatar
  self.remote_avatar? ? self.remote_avatar : self.local_avatar
end

In the views you will do:

<%= f.file_field :avatar %>

<%= image_tag @user.avatar.url(:thumb) %>

I really like this solution because it’s simple and non intrusive.
Alternatives:

• Delayed upload delivery to S3 with Paperclip + Delayed::Job(1 table, 2 models, temporary local files. nice solution)
• Uploading files directly to Amazon S3 using FancyUpload

Delaying the thumbnail generation

For this one I’ve made a mix of two solutions that I found:

• Delaying Paperclip(broken link)
• Paperclip, S3 & Delayed Job in Rails

First of all, it’s necessary to add a column (processsing, for instance) to flag that the thumbnail isn’t ready. Once you’ve done that, we have to prevent the thumbnail generation.

before_local_avatar_post_process do |image|
  if image.dirty?
    image.processing = true
    false # halts processing
   end
end

That will prevent any image processing by paperclip. Now we just need to implement a method to let the paperclip to do it and put on background, in this recipe using the delayed_job:

after_save :queue_process_styles

def queue_process_styles
  send_later(:process_styles) if self.local_avatar.dirty?
end

def process_styles
  self.local_avatar.reprocess!
  self.processing = false
  self.save(false)
end

And for placeholder image to show the thumbnails during the processing, just use the option default_url:

has_attached_file :local_avatar, :styles => { :medium => "120x120>", :thumb => "80x80>" },
  :default_url =>  ":class/:attachment/:style/processing.png"

• delayed_paperclip

Anonymous photos

To implement it, we have to customize the file path using the options path and url:

has_attached_file :local_avatar,
  :url => "/system/:attachment/:id/:style/:filename",
  :path => ":rails_root/public:url"

The value of each of those words beginning with : is determined by a method of the Paperclip::Interpolations. The :attachment, for instance, returns the pluralized name of the attachment as given to has_attached_file. To create one is very simple:

Paperclip.interpolates :anonymous do |attachment, style|
  Digest::SHA1.hexdigest("#{attachment.instance.id}")
end

Back to our example:

has_attached_file :local_avatar,
  :url => "/system/:attachment/:id/:style/:anonymous.:extension",
  :path => ":rails_root/public:url"
#example:
#/system/local_avatars/12/original/7b52009b64fd0a2a49e6d8a939753077792b0554.jpg

I don’t know if SHA-1 is the best way to do it and I would like to receive suggestions to improve this code.

Alternatives:

• :id
• :id_partition
• :timestamp
• an interpolation created by you

Photo dimensions

The class Paperclip::Geometry has methods to get the image dimensions. We just need to add the columns(width and height, for instance) and set their values using an appropriate callback:

before_save :set_dimensions

def set_dimensions
  tempfile = self.local_avatar.queued_for_write[:original]
  
  unless tempfile.nil?
    dimensions = Paperclip::Geometry.from_file(tempfile)
    self.width = dimensions.width
    self.height = dimensions.height
  end
end

That’s it!

Uploaded successfully!

I wanted to share the above recipes as I figure they are useful to those working in similar projects. I’d like to thank those who have worked on the projects mentioned above: Christopher Saylor, Bruno Miranda and Dante Regis.
Thank you for reading!

Photo by williac

Last week my friend Davis Cabral asked me about some nice apps to install in his new iPhone. I have an iPod Touch and seldom if ever use it to listen to music. In fact, my wife and I called it “the house computer”. Davis asked the right person, and below there are my thoughts about some of my favorite apps.

Reading

After I finished reading all paper books I own, I chose to read some classic ‘virtual’ books using my iPod. A Kindle would be better (right Bruno?), but unfortunately it’s unavailable in my country. At least there are good reader apps for iPhone OS. I’ve already read the short-story I, Robot written by Cory Doctorow (what I started to read because I thought it was the Asimov’s book…) using the Stanza app and currently I’m reading Alice in Wonderland using the Classics app. The both are nice apps, each one with its own characteristics.

Classics has an impressive and beautiful UI with a virtual shelf, ‘page flip’ animation and bookmarks. There are twenty three available books so far. $0.99.

Stanza has a (bugged) UI with many options (colors, layout, orientation) and lets you browse many catalogs with paid and free ebooks like O’Reilly Ebooks and Project Gutenberg. And it’s not only that, there is a desktop app to sync your own files. Free.

Besides the usual books, I read comic books and there are some nice solutions for iPhone OS, eg.: PullLists, Comic Reader Mobi.

I’m using the Comiczeal what syncs with the ComicZeal Sync(for Mac and Win) and has a good file management, unfortunately only in the iPhone side. $0.99.

Games

When I wanna play some video game, there are two what I really like: Zenonia and Real Soccer 2009.

Zenonia is an old school RPG game… in fact, it is a fun RPG action game that mixes many cool features of some great RPG games. There are three classes to choose(paladin, warrior and thief) a lot of NPCs, items, weapons, monsters, active and passive skills and it’s a long game (I’ve already played 14 hours along about two months and I think I played only half of it). Free Lite version, Full $2.99.

Real Soccer 2009 is a soccer game(oh!) with nice graphics and gameplay. However, its best part is the intuitive controls that make it better to play than Pro Evolution Soccer for PC with a joystick! With just a direction pad and two buttons you get 17 moves. Sometimes I catch my wife playing it. $0.99.

In the next part I’ll write about apps in other categories: Productivity, Social Networking and Home Entertainment.

Photo by meaghan murphy.

E o premiado foi: Pedro Delfino dos Santos Neto (twitter, blog). Parabéns ao ganhador e bons estudos!

Para quem estiver interessado no livro, até o final de maio poderá usar o código RUBYONDA para comprar o livro com 20% de desconto no site da NOVATEC.

Livro RubyOnRails - Urubatan

E agora a melhor parte, a editora cedeu ao RubyOnda uma cópia do livro para sortearmos entre nossos colaboradores. Para concorrer basta enviar pelo menos um post para o RubyOnda até 25/04/2009.

E quem não ganhar não precisa ficar triste, até o final de maio poderá usar o código RUBYONDA para comprar o livro com 20% de desconto no site da NOVATEC.

I am currently developing Rails applications for Todobebe. Whenever possible I spend time studying Perl, Cocoa amongst other things. Expect to see items related to those subjects here.

Some posts will be in portuguese, normally when I write about local events.

Feel free to subscribe to the feed.