Hi, everybody,

I am a new blogger for RailsSpace. Two words about me; I am Italian (so forgive the occasional slip-up) and US resident (Bay Area). After years of real-time apps (network mgmt, Snmp), I began a sabbatical into scripting languages; after a furious flirt with Perl, I finally met Ruby (and nothing was ever the same again..). Recently, I began to read RailsSpace, and I was granted the chance to comment some aspects of the code.

I start discussing the Login action, at its inception, in chapter 6:

def login
  if request.post? and params(:user)
    @user = User.new(params[:user])
    user = User.find_by_screen_name_and_password(@user.screen_name,
                                                 @user.password)
    if user
      session[:user_id] = user.id
      # flash and redirect
    else
      @user.password = nil
      # flash
    end
  end
end

The weak point is this juggling between the @user (the user received from the form) and user (the one from the database) structures at every statement. This usage only intensifies in the next chapters as the method becomes progressively more complex. Could we have only 1 structure? Yes, if we collect the user credentials from params:

def login
  if request.post? and params(:user)
    screen_name = params[:user][:screen_name]
    password    = params[:user][:password]
    @user = User.find_by_screen_name_and_password(screen_name, password)
    if @user
      session[:user_id] = @user.id
      # flash and redirect
    else
      # bad credentials: return data rcvd, but wout password
      @user = User.new(params[:user])
      @user.password = nil
      # flash
    end
  end
end

Notice that we now need to create the user in the else branch; but the benefit is that there is only 1 structure across the whole method (which, as said, will become quite complex later). And the method is more efficient, as (in the succesful case) we call only once ActiveRecord to build the user.

Ah, some may say, we do have only 1 structure, but we now access a nested hash!: is this what you call simplification?..

Answer: we can hide the access to the data in a method; it will be generic for any object and any nr of attributes; so the usage will be:

name, pwd = params_for(:user, :screen_name, :password)

# retrieves named params from object
def params_for(object, *names)
  obj_hash = params[object.to_sym]
  return [ ] unless obj_hash

  names.inject([]) { |arr, name| arr << obj_hash[name.to_sym] }
end

This method iterates across the array of names received, extracting the values from the nested hash, and feeding the result array (inject is a cute way to iterate accumulating a result, without creating extra local variables; very idiomatic inside Rails code).

All right; so the login looks like:

def login
 if request.post? and params(:user)
   name, pwd = params_for(:user, :screen_name, :password)
   @user = User.find_by_screen_name_and_password(name, pwd)
   # all the rest of the logic is as above
end

Now the resulting method uses only 1 user structure, and the extraction of parameters is friendly enough. As the method complexity escalates in following chapters (‘remember_me’, cookies, etc), the programmer can concentrate on the features (without worrying about which structure to access at each statement).