Fabien Jakimowicz

[Ruby] On val.respond_to? x, but val.x is undefind for val?

2010-07-07T11:03:17-07:00

If your are in Rails project, take a look at HashWithIndifferentAccess

h = {:asdf => 'toto', :titi => 42}
 => {:asdf=>"toto", :titi=>42}
h2 = HashWithIndifferentAccess.new(h)
 => {"titi"=>42, "asdf"=>"toto"}
h2[:titi]
 => 42
h2['titi']
 => 42

[Ruby] On Validate the nested model

2009-03-24T12:42:26-07:00

I'm not sure why you need to manually validate each questions since ActiveRecord should validate them before saving.

Anyway, here is a better way to do it.

## Round model
class Round < ActiveRecord::Base
  belongs_to :season
  has_many :questions, :dependent => :destroy

  def validate
    errors.add("questions", "are invalid") unless questions.all? {|q| q.valid?}
  end
end

## Question model
class Question < ActiveRecord::Base
  belongs_to :round
end

## Rounds controller
class RoundsController < ApplicationController
  def publish
    @round = @season.rounds.find(params[:id])
    @round.update_attributes! :published => true
    flash[:notice] = 'Round was successfully published.'
  rescue ActiveRecord::RecordInvalid
    flash[:notice] = 'Round has invalid questions.'
  ensure
    redirect_to season_round_path(@round.season, @round)
  end
end

[Ruby] On Too many for loops

2009-02-25T14:20:43-08:00

You can optimize a little bit your code but you will have to modify your models.
Take a look at :through argument in ActiveRecord::Base/has_many documentation.

PS: if you precise a little bit your models and relations, maybe we can find a better solution

## User model
class User < ActiveRecord::Base
  has_many :classrooms
  has_many :assignments, :through => :classrooms
end

## Users Controller
class UsersController < ApplicationController
  def dashboard    
    @submitted_assignments = Assignment.find(:all, :joins => :student_assignments)
    @assignments = current_user.assignments
  end
end

## View: dashboard.html.haml

- for assignment in @assignments
  - for sa in assignment.student_assignments
    = sa.id

[Ruby] On Re-Refactor Mailer Conditions

2009-02-14T10:46:29-08:00

You should use callbacks and exceptions ;)

I consider your current_account.announcements as Announcement model, and the current_account leads to a user model.

## Announcement model
class Announcement < ActiveRecord::Base
  ANNONCEMENT_TYPES = {'squad'    => :deliver_squad_announcement,
                       'everyone' => :deliver_general_announcement,
                       'tryout'   => :deliver_general_announcement}

  belongs_to :user

  after_create :deliver_announcement

  def deliver_announcement
    AnnouncementMailer.send ANNONCEMENT_TYPES[sent_to], self, user
  end
end

## Controller code
def create
  @announcement = current_account.announcements.build(params[:announcement])
  @announcement.save!
  flash[:notice] = 'Announcement was successfully created.'
  respond_to do |format|
    format.html { redirect_to(@announcement) }
    format.xml  { render :xml => @announcement, :status => :created, :location => @announcement }
  end
rescue ActiveRecord::RecordInvalid
  flash.now[:error] = 'Something went wrong.'
  respond_to do |format|
    format.html { render :action => "new" }
    format.xml  { render :xml => @announcement.errors, :status => :unprocessable_entity }
  end
end

[Ruby] On While loop to get unique value

2009-02-12T13:34:06-08:00

If you are using ActiveRecord and if your database supports it you should use unique indexes.

## Index creation
add_index(:vouchers, [:vouchercode], :unique => true)

## Voucher model
class Voucher < ActiveRecord::Base
  def create_or_update
    super
  rescue ActiveRecord::StatementInvalid => e
    if e.to_s =~ %r{index_vouchers_on_vouchercode}i
      self.vouchercode = generate_vouchercode(8)
      retry
    else
      raise
    end
  end
end

[Bash] On Unzip large database dump directly into mysql

2009-02-12T12:36:28-08:00

Not really better, but you save a few keystrokes.

zcat database_dump.sql.gz | mysql -u username -h host -p password database

[Ruby] On Caesar Cipher

2008-08-09T11:34:30-07:00

def caesar(text, shift)
  text.split('').collect {|letter| (letter[0] + shift).chr}.join
end

[Ruby] On Rails - Multiple instances and folder creation

2008-08-03T12:48:33-07:00

You should move a lot of logic down to models.

In this code, you should add some checks on folder creation and folder deletion on website/account destroy. You can also reduce controller code by nesting forms (user and website will be in account params hash) and using an after_create on account model to create user and website. But this could be overkill ;)

## Account model
class Account < ActiveRecord::Base
  has_many :websites
  has_many :users

  validates_presence_of :name

  before_create :make_short_name

  private
  def make_short_name
    self.short_name = name.gsub(/\W+|\s+/, '-').downcase
  end
end

## Website model
class Website < ActiveRecord::Base
  belongs_to :account

  validates_presence_of :name
  validates_associated :account # we rely on account short_name, we must check it
  validates_uniqueness_of :short_name, :scope => :account_id # You could have some surprises with your folders if you don't check it

  before_create :make_short_name
  after_create :make_base_folders

  Folders = %w{docs pictures users}

  private
  def make_short_name
    self.short_name = name.gsub(/\W+|\s+/, '-').downcase
  end

  def make_base_folders
    Folders.each {|folder_name| FileUtils.mkdir_p "#{RAILS_ROOT}/public/content/#{account.short_name}/#{short_name}/#{folder_name}"}
  end
end
## User model
class User < ActiveRecord::Base
  belongs_to :account

  validates_associated :account
end
## Controller
def create
  @account = Account.create!(params[:account])
  @user = @account.users.create!(params[:user])
  @website = @account.websites.create!(params[:website])
  flash[:notice] = 'Your account was successfully created. Please login to begin :)'
  redirect_to login_path
rescue
  render :layout => 'signup', :action => 'new'
end

[Ruby] On How to make instance variable Persistent in between actions

2008-07-31T13:33:31-07:00

You can use a before filter to avoid code duplication.

But keeping 'dynamic' data between queries is not always a good idea : data can change between 2 queries and you can have inconsistent data.

Anyway, you can use session to store data between queries. Here are 2 solutions.

You can even remove action definition if there are empty, but you will loose code clarity

## avoiding code duplication
class MyaccountController < ApplicationController
  before_filter :load_users, :only => [ 'account_details', 'show_email_box', 'show_mobile_box' ]
    
  def account_details
  end
  
  def show_email_box
  end
  
  def show_mobile_box
  end

  private
  def load_users
    @users = User.find(:all,:conditions=>"age > #{current_user.age}")
  end
  
end

## persistent storage between queries in session
class MyaccountController < ApplicationController
  before_filter :load_users, :only => [ 'account_details', 'show_email_box', 'show_mobile_box' ]
    
  def account_details
  end
  
  def show_email_box
  end
  
  def show_mobile_box
  end

  private
  def load_users
    session[:users] ||= User.find(:all,:conditions=>"age > #{current_user.age}")
    @users = session[:users]
  end
  
end

[Ruby] On Saving multiple models in one action

2008-07-29T22:21:27-07:00

there is a lot of way to clean this, but without any other information (relation type between @foo and bar, form, ...) i can just propose something using exceptions and transactions.

A transaction will roll back any modifications if there is any failure. In your case, you need to save both instances only if both of them are valid. If one fail, the entire transaction will fail and nothing will be saved

def update_foo_and_bar
  # You can also use @foo.class.transaction and @foo.bar.class.transaction if you have multiple database at the same time
  ActiveRecord::Base.transaction {@foo.update_attributes!(params[:foo]) and @foo.bar.update_attributes!(params[:bar])}
  redirect_to foo_url(@parent)
rescue ActiveRecord::RecordNotSaved
  render :action => 'edit'
end

[Ruby] On cleaner way to limit results from xml

2008-07-14T23:38:12-07:00

i'm not familiar with REXML library, but in the api doc there is a function to_a, you should give it a try.

xml = REXML::Document.new(data)

artists = xml.elements.to_a('//artist')[0..limit].collect do |artist|
{"name" => artist.elements['name'].text
end

[Ruby] On Python's enumerate in Ruby?

2008-07-14T23:23:43-07:00

['foo', 'bar', 'baz'].each_with_index {|j, i| puts "#{i} #{j}"}

[Ruby] On collecting attributes from find(: all) method

2008-06-17T15:32:51-07:00

I thought the same about html select rails helper but it was supposed to render it flatten, so be it ;)

[Ruby] On collecting attributes from find(: all) method

2008-06-17T11:52:32-07:00

# Rails < 2.0
Carrier.find(:all).collect {|d| [d.id, d.name]}.flatten

# Rails >= 2.0.2
Carrier.all.collect {|d| [d.id, d.name]}.flatten