I chose to use MongoMapper, a ruby object mapper for Mongo. MongoMapper uses ActiveModel and let you interact with a MongoDB database in a very ActiveRecord way.

Hope this sample app will help you getting started with MongoDB!

Say I have a horse racing ruby application that allow people to know information about every competing horses. I have an input box that people can use to enter the name of a horse. Once they click OK, information about the specified horse is displayed to the user.

Instead of going the traditonal route, how about adding a “horse” method to the String class? It could not be easier :

HORSES = [
  {
    :name => "Jolly Jumper",
    :also_known_as => ["Smart Arse","Lucky Luke friend"],
    :speed => 3, :intelligence => 30,
    :favorite_quote => "I am a horse, I don't have quotes"
  },

  {
    :name => "Incredibly Bad",
    :also_known_as => ["Shame","The Pathetic"],
    :speed => 2, :intelligence => 4,
    :favorite_quote => "If you still put your money on me, you only have yourself to blame"
  },

  {
    :name => "Fast And Furious",
    :also_known_as => ["The Strong Rebel","The Furious One"],
    :speed => 50, :intelligence => 15,
    :favorite_quote => "I am fast"
  },

 {
    :name => "Slow and Jerky",
    :also_known_as => ["Tender","Terrible Choice"],
    :speed => 1, :intelligence => 10,
    :favorite_quote => "Pick me once, regret it for a lifetime."
  }
]

class String
  def horse
    res = HORSES.select { |h| h[:name] == self || h[:also_known_as].include?(self)}
    res.first if res.length>0
  end
end

#Then you can do stuff like this :
horse = "Tender".horse
if horse
	puts "#{horse[:name]}, also known as #{horse[:also_known_as].join(", ")}, has a speed of #{horse[:speed]} and an intelligence of #{horse[:intelligence]}. In its free time, this horse like to become all philosophic, look at the sky and say : '#{horse[:favorite_quote]}'"
else
	puts "This horse doesn't exists in our records"
end

Talk about some great syntactic ruby sugar!

Exemple of a mess in a controller :

def index
  if administrator?
    @books = Book.all
  else
    @books = Book.published
  end

Example of a mess in a view :

<%if administrator?%>
<%=render :partial => "admin_index"%>
<%else%>
&lt;h1&gt;Published books&lt;/h1&gt;
bla bla bla
<%end%>

If you go that route, be prepared to make your fingers bleed because you will write tons of confusing and ugly “if” statements everywhere. Most of the time anyway, what you need to do with the resources is completely different depending if you’re on the admin or public side, so you’re better to separate them.

Step #1 : Generating the controllers
To generate a public controller, you do like you always do : ./script/generate controller books

To generate its admin counterpart, you simply do this : ./script/generate controller admin/books

Rails will generate the controller in controllers/admin/books_controller.rb and a folder for the views in views/admin/books

Step #2 : Configuring the routes
One route for the public side :

map.resources :books, :only => [:index, :show]

One route for the admin side

map.namespace :admin do |admin|
  admin.resources :books
  admin.resources :some_other_resource
end

Now your namespaced controller has its own named urls as well : admin_books_url, edit_admin_book_url and so on…

Step #3 : Get the “form_for” url right

<%form_for [:admin, @book] do |f|%>
   <%=f.text_field :title%>
   <%=f.submit "Save"%>
<%end%>

That way Rails will correctly call the update/create method in controllers/admin/books_controller.rb instead of the one in controllers/books_controller.rb

A final note
The controllers and the views are best kept separated but NOT the model which should always remain unique in your app.

So, how to do this? With encryption, of course.

The thing is that most encryption algorithms will generate ciphers with non-friendly characters, like : Òèç`{&[ùỲgǛ... so bad for readability. It seems complicated at first but finally one solution turns out to be fairly simple :

Step #1

sudo gem install crypt

Step #2

blowfish = Crypt::Blowfish.new(SOME_KEY)
crypted_but_readable = blowfish.encrypt_block("12345678").unpack("H*")

Step #3

  crypted_block = params[:some_crypted_but_readable_block].to_s
  if crypted_block.length == 16
    blowfish = Crypt::Blowfish.new(THE_SAME_KEY)
    decrypted_block = blowfish.decrypt_block(crypted_block.to_a.pack(“H*”))
    #do something with decrypted block
  end

The Blowfish algorithm takes 8-bytes blocks only... so you have to take that into account when you generate your keys. The unpack("H*) and pack("H*") parts are the most important. It simply encodes/decodes the block in hexadecimal. So, here we are, you have a readable & decryptable 16-chars cipher that looks like : 9048bb8f56eddd47. You can even display the codes into chunks of 4 characters and it gives you the following friendly code : 9048-bb8f-56ed-dd47

Tip: Associate to each code a SHA-1 hashed password (which is the result of activation code + some salt) and you have a pretty safe account activation procedure that doesn't pollute your database.

Here is a quick and easy way to automate the process :

Step #1 (we can have lots of fun)
I will consider that you use capistrano for deploying your app. The only thing you have to do in your capistrano recipe is to “touch” a dummy file to update its modification date.

namespace :deploy do
  desc 'Restart My App'
  task :restart, :roles => :app do
    run "touch #{current_path}/last_deploy"
  end
end

Step #2 (there’s so much we can do)
Now in application_controller, add a before_filter like this

before_filter :last_deploy

def last_deploy
  @last_deploy = File.new("last_deploy").atime rescue Time.now
end

Step #3 (it’s just you and me)
Display the date in the layout or in the view of your choice

<%= "Last deployment : #{@last_deploy}"%>

Edit : Oh, dear readers, I just want to let you know that RubyFleebie is now on Twitter.

I’m sorry for not updating my blog more often. Now is the time to use the best excuse in the world that will make me look like a busy businessman and you will all be impressed. Here we go : I don’t have the time!

I know a lot of you are using GOD to keep your daemons / processes alive. I really don’t want to say bad things about GOD (I can’t because I never tried it)… but I DID read some really nasty things about it and somehow it convinced me to try an alternative : Monit.

The biggest advantage with Monit is that it is written in C instead of ruby… so it doesn’t leak and it appears to be faster. It is also pretty easy to configure. Here is a very basic monit configuration file:

set daemon 60

set httpd port 2812 address localhost
     allow localhost 

check process my_process
  with pidfile /home/apps/someapp/my_process.pid
  start program = "/home/apps/someapp/my_process start"
  stop program = "/home/apps/someapp/my_process stop"

Then, you start the monit daemon by typing : monit

It will poll the monit configuration file every minute (this is the set daemon 60 part) and will restart ‘my_process’ whenever it is not running. Of course this is an extremely simple use case and there are a lot more configuration options you can play with. Have a look at the documentation for more info.

I’m struggling since day #1 to find a good code editor for ruby. Mac users are happy with their textmate… but what’s left for us linux users? I tried gedit, vim, scribes and eclipse (with the aptana plugin) but wasn’t happy enough with any of them. I thought I found a real gem in Komodo edit, but that’s just not doing it for me anymore. Komodo is a great editor but it is plagued with a huge problem : it is slow and unresponsive. Sometime you start typing code and you won’t see what you just typed on the screen. Wait a few seconds and boom, here is your code… full of typos.

Now that my honey moon with Komodo is over, I searched the web and found Geany, a light-weight code editor that works for linux and windows. I’m very satisfied with it so far. Instead of making a half-assed review of the editor, I think you should try it by yourself and decide if you like it or not.

Off topic note :

Those who liked the “in depth” posts I was doing in the early days of this blog might be disappointed with the kind of posts I’m doing now. I’m thinking about this for some time and I can say that I am planning to start writing like those early days. Why? Well, simply because I found it more enjoyable. The problem however is finding the time to write longer and more in-depth posts. I am currently quite busy with TimmyOnTime and other projects so unfortunately RubyFleebie is suffering from it. I want to thank you for your patience… it amazes me that I still have all those subscribers and daily readers.

Say I have these 2 arrays :

colors1 = [:blue, :red, :green, :orange, :purple]
colors2 = [:yellow, :cyan, :green, :blue, :purple]

Now what if I want a new array that contains only the elements present in both arrays?

beautiful_colors = colors1 & colors2
#beautiful_colors contains [:blue, :green, :purple]

Have a nice weekend!

Cart model (as in : shopping cart)

class Cart < ActiveRecord::Base
  has_one :bill
  belongs_to :user
end

Bill model

class Bill < ActiveRecord::Base
  belongs_to :cart
end

User

class User < ActiveRecord::Base
  has_many :carts
  has_many :bills, :through => :carts #<== Doesn't work... no user.bills for you!
end

Basically, because the "through" table links the destination table with a has_one relationship, ActiveRecord complains with : Invalid source reflection macro :has_one for has_many :bills, :through => :carts. Use :source to specify the source reflection.

Someone on Rails Trac already created a ticket about this issue 2 years ago. Can we expect this feature to be officially supported in the future? Let's hope so.

Note : Those who don’t know what this plugin is all about should stop reading right there or risk being completely lost.

One thing that seems impossible to do with the plugin is to have variable “initial states” for an object. Say for example that you have a User model that needs to act as a state machine. New users have to fill up a signup form to gain access to the application. These new users will be “pending” until an administrator approve them (enabled) or refuse them (disabled)

class User < ActiveRecord::Base
  acts_as_state_machine :initial => :pending
  state :pending
  state :enabled
  state :disabled

  event :enable do
    transitions :from => :pending, :to => :enabled
    transitions :from => :disabled, :to => :enabled
  end

  event :disable do
    transitions :from => :pending, :to => :disabled
    transitions :from => :enabled, :to => :disabled
  end
end

So far so good. But what if an administrator can also create a new user? In this case we would’nt want the user to be “pending”, we want him to be “enabled” right away.

I experimented a similar scenario, so I tried a few things to bypass the initial state :

#FAILED ATTEMPT #1
def create
  user = User.new(params[:user])
  user.state = :enabled
  user.save
end

Too bad, so I tried this :

#FAILED ATTEMPT #2
def create
  User.initial_state = :enabled
  user = User.new(params[:user])
  user.save
end

Of course, the following worked :

#SUCCESSFUL BUT SUCKY ATTEMPT
def create
  user = User.new(params[:user])
  user.save
  user.enable!
end

Yuk… there had to be something better.

Finally, I learned that initial_state was an inheritable attribute. I didn’t know what those were all about so I did some googling. The only good explanation I found is this one.

Anyway, I was able to override the initial state of my user object by doing this :

#SUCCESSFUL ATTEMPT!
def create
  User.write_inheritable_attribute :initial_state, :enabled
  user = User.new(params[:user])
  user.save
end

It’s not pretty I know, but at least it gets the job done. I wonder if the fact that you cannot “easily” change the initial state programmatically is a missing feature that should be added in a future version… or if it’s only my understanding of a “state machine” that sucks. Any thoughts?