La rolls des blogs » ruby on rails

ActiveRecord like searching object in Rails form helpers

Hallelujah — Wed, 17 Nov 2010 00:29:22 +0000

Ruby is a wonderful language. And Rails is a wonderful framework.
Why ? Because of Duck typing !!!

Example :

You build a database application for a book store

Books are classified by :

Genre
Author
Country

On a search page, you can search with a title text field, author select box, genre checkboxes.
So we want to create a search form with all the fields described above :

<%= form_tag('/search') do %>
  
    title
    <%= text_field_tag 'title' %>
  
  
    Author
    <%= select_tag 'author',  options_for_select @authors, @selected_author %>
  
  <% @genres.each do |g| %>
    
      <%= 'genre_' + g.id.to_s %>"><%= g.label %>
      <%= check_box_tag 'genre[]', g.id, g.id == @selected_genre, :id => "genre_#{g.id}" %>
    
  <% end %>
<% end %>

When I submit the code, it does not keep the value of the search fields, as it is when passing activerecord object in form helpers (with text_field not text_field_tag.)
Ok!! And what if I construct an object behaving like activerecord object ?
My template will be like this :

<%= form_for @search do |f| %>
  
    <%= f.label :title, 'Title' %>
    <%= f.text_field :title %>
  
  
    <%= f.label :author, 'Author' %>
    <%= f.select :author, @authors %>
  
 
  <% @genres.each do |g| %>
    
      <%= 'genre_' + g.id.to_s %>"><%= g.label %>
      <%= check_box_tag 'search[genre][]', g.id, g.id == @selected_genre, :id => "genre_#{g.id}" %>
    
  <% end %>
  <%= submit_tag "Search" %>
<% end %>

Yes we have a namespace called “search” on all parameters such as “search[title]” but I think it is not ugly, instead the code will be more readable !!!
Ok, but what’s the magic ? How can I have an activerecord like search object ?

Simply like that :

# encoding: utf-8
class Search
  def initialize(params={})
    @params = Hash.new.merge(params['search'] || {})
  end 
 
  def method_missing(method_sym,*args)
    case method_sym.to_s
    when /^\[\]=?$/
      @params.send(method_sym,*args)
    when /^(.*)=$/
      @params.update($1,*args)
    else
      @params[method_sym.to_s]
    end
  end
 
end

In your controller, simply instantiate a @search variable with your parameters :

# app/controllers/search_controller.rb
 
def search
  @search = Search.new(params)
  # ....
end

Ruby Rails : How to bypass skip validation in Devise

Hallelujah — Wed, 20 Oct 2010 16:25:34 +0000

Since my last post with email validations, I was looking for a solution to integrate it with devise

Sadly for me, devise implements the old way of validating email with regexp :

# From devise gem version 1.1.3
validates_format_of     :email, :with  => email_regexp, :allow_blank => true

Well, as I don’t want to hack activemodel’s code, I prefer to skip the validates_format_of method in User class.

class User < ActiveRecord::Base
  # Include default devise modules. Others available are:
  # :token_authenticatable, :confirmable, :lockable and :timeoutable
  include SkipableMethod
 
  # Devise is great but uses the oldest way with regexp to validate email
  skip_and_restore_method(:validates_format_of) do
    devise :database_authenticatable, :registerable,
      :recoverable, :rememberable, :trackable, :validatable
  end
 
  # Replace with a validation of my own
  validates :email, :email => true, :presence => true
 
  # Setup accessible (or protected) attributes for your model
  attr_accessible :email, :password, :password_confirmation, :remember_me
 
end

And then the library :

module SkipableMethod
  module ClassMethods
 
    protected
    def __skip_method(*args);end
 
    def skip_and_restore_method(*method_names,&block)
      method_names.each do |method_name|
        instance_eval <<-EVAL
        alias #{method_name}_skipped #{method_name}
        alias #{method_name} __skip_method
        EVAL
      end
 
      yield
 
      method_names.each do |method_name|
        instance_eval <<-EVAL
        alias #{method_name} #{method_name}_skipped
        undef #{method_name}_skipped
        EVAL
      end
    end
  end
 
  def self.included(receiver)
    receiver.extend         ClassMethods
  end
end

TODO :

Some tests

Enumerable grep method in Ruby

Hallelujah — Thu, 19 Aug 2010 13:43:08 +0000

There is some methods that are not very known among ruby developpers.
One of them is Enumerable#grep method.
I would like to share one of the use case I have to face with, and how I implement grep.

Purpose, I have a Hash representing a simple network
I’d like to select all the people related to :patrick with network label as key.

# Say I have this hash
h = {
  :work => { :patrick => [:joana, :elvis] },
  :football => { :patrick => [:john, :fred, :marcus] , :john => [:paul, :patrick]},
  :friends => { :paul => [ :joana, :elisabeth]}
}
# I want this result :
{
  :work => [:joana,:elvis],
  :football => [:john, :fred, :marcus]
}

A solution is to iterate throug each values then select :patrick

  h.inject({}) do |memo,(k,v)|
   if v.has_key?(:patrick)
    memo.merge(k => v[:patrick])
   else 
    memo
   end
  end

Though it works, I think this piece code is not “rubyesque”.

Well, this is a basic case but imagine you have to select X number of variables or more ( :patrick,:paul … etc ) or worse select with a more complex criteria.

After digging into the rdoc documentation, it seems that Enumerable#grep matches our requirements :

It takes a parameter to compare with each elements of the Enumerable
It can take a block that returns the value of matching elements

Well, how can we implement that ?
This code below demonstrate why I love Ruby !

class NetworkPattern
  def initialize(*args)
    @matches = args
  end
 
  def ===(pair)
     key, value = pair
     value.values_at(*@matches).any?
  end
 
  def result(hash)
    hash.values_at(*self).compact.flatten
  end
 
  def exec(hash)
    Hash[ hash.to_a.grep(self){|k,v|  [k,self.result(v)] } ]
  end
 
  def to_a
     @matches
  end
end
 
pattern = NetworkPattern.new(:patrick)
 
Hash[ h.to_a.grep(pattern){|k,v|  [k,pattern.result(v)] } ] 
=> { :work => [:joana, :elvis], :football=>[:john, :fred, :marcus]}
# With somer refactoring, we implement NetworPattern#exec and use it 
pattern.exec(h)
=> { :work => [:joana, :elvis], :football=>[:john, :fred, :marcus]}

Well it may seem more complicated but if you want to select both :patrick and :paul relationships, the code does not change howmany arguments you pass in NetworkPattern.new

pattern = NetworkPattern.new(:patrick, :paul)
pattern.exec(h)
=> { :work => [:joana, :elvis], :football =>[:john, :fred, :marcus], :friends =>[:joana, :elisabeth]}

All the logic belongs to the class NetworkPattern and it uses Enumerable#grep with block return.
In your project you can use something like that since it can be easily tested and more readable.

Email validation in Ruby On Rails 3 or Active model without regexp

Hallelujah — Wed, 21 Jul 2010 08:21:42 +0000

In Rails 3.0, you can use custom validator in your active_record model.
So I wanted to manage email validations without regexp matching like others do.
I find a new way to make this work thanks to ruby mail gem, a dependency of Rails 3.0

I use this with devise, see my blogpost here : Ruby Rails : How to bypass skip validation in Devise

Edit : Here is a gem https://github.com/hallelujah/valid_email

class User < ActiveRecord::Base
  validates :email, :presence => true, :email => true
end

Just put a file in app/validators/email_validator.rb

require 'mail'
class EmailValidator < ActiveModel::EachValidator
  def validate_each(record,attribute,value)
    begin
      m = Mail::Address.new(value)
      # We must check that value contains a domain and that value is an email address
      r = m.domain && m.address == value
      t = m.__send__(:tree)
      # We need to dig into treetop
      # A valid domain must have dot_atom_text elements size > 1
      # user@localhost is excluded
      # treetop must respond to domain
      # We exclude valid email values like 
      # Hence we use m.__send__(tree).domain
      r &&= (t.domain.dot_atom_text.elements.size > 1)
    rescue Exception => e   
      r = false
    end
    record.errors[attribute] << (options[:message] || "is invalid") unless r
  end
end

No regexp !! And beautiful !!

Here is the version without activerecord

require 'rubygems'
require 'active_model'
require 'active_support/all'
require 'active_model/validations'
require 'mail'
class EmailValidator < ActiveModel::EachValidator
  def validate_each(record,attribute,value)
    begin
      m = Mail::Address.new(value)
      # We must check that value contains a domain and that value is an email address
      r = m.domain && m.address == value
      t = m.__send__(:tree)
      # We need to dig into treetop
      # A valid domain must have dot_atom_text elements size > 1
      # user@localhost is excluded
      # treetop must respond to domain
      # We exclude valid email values like 
      # Hence we use m.__send__(tree).domain
      r &&= (t.domain.dot_atom_text.elements.size > 1)
    rescue Exception => e
      r = false
    end
    record.errors[attribute] << (options[:message] || "is invalid") unless r
  end
end
 
class Person
  include ActiveModel::Validations
  attr_accessor :name, :email
 
  validates :name, :presence => true, :length => { :maximum => 100 }
  validates :email, :presence => true, :email => true
end