La rolls des blogs

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

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

How to translate your column fields and values with gettext in ruby on rails

Hallelujah — Wed, 07 Jul 2010 10:55:25 +0000

I am proud to have published my first useful ruby gem.
It is called gettext_column_mapping, you can check out the code in my github repository.
I already released it as a gem through gemcutter/rubygems

It is based upon Masao Mutoh (gettext and gettext_active_record) and Michael Grosser (fast_gettext and gettext_i18n_rails) works.

Thanks to them

History

In my company we need a mean to translate bad written fields/table name in our database. Why ? because our applications are internationalized and we need to have cleaner name than “libelle” (the french word standing for label) to send to translators.

We also have some “constants” name saved in our tables so we need to translate them.

Then started this library a year ago.

Formerly, it was a library that depends on Rails … But I decided that it ccould be nice if it reaches these requirements :

Use of Rubygem to spread it more easily
Must be Rails agnostic
Can use either mutoh’s gettext or grosser/fast_gettext
Can be implemented easily on rails 2.3.x and 3.0 or other ruby web framework
Can have some built-in configurable rake tasks

All is done!

But now I would like to improve this gems (API, tests, documentation, implementation) , so if someone who reads this post can help … I must remind you that this project is open source. Partly, it has been developped at work but I burnt most many hours of my sparetime than at work

TODO ?

other database implementation (only mysql for now)
ORM agnosticism ?
More testing
More documentation
Rails < 2.3 compatibility backward
… and so many

Try it and give me feedback

Bundler default Gemfile and custom Gemfile, example of wirble

Hallelujah — Tue, 29 Jun 2010 13:38:34 +0000

Hi all,
A simple trick I want to share with you if you are using Bundler (or rails 3)
It matters if you want to install wirble gem in your workstation but not in your server

Sometimes, you want to include some gem that are not mandatory for your application to run but you want to use in your workstation. E.g wirble, awesome_print etc … or other debugging tools

Just write something like this in your Gemfile

# Gemfile
if File.exist?(file = File.expand_path('../myGemfile',__FILE__))
  instance_eval(File.read(file))
end

Now in your myGemfile

# myGemfile
gem 'wirble'
gem 'awesome_print'

That’s all! You can now require ‘wirble’ or ‘awesome_print’ in your rails console

Mysql 4.x and Rails : RELEASE SAVEPOINT issue

Hallelujah — Thu, 11 Mar 2010 09:32:37 +0000

Today with a project using mysql 4.1.22 that I have to implement some tests, I ran this error with rails 2.3.5 and I think for 2.3.x branch.

Mysql::Error: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near ‘RELEASE SAVEPOINT active_record_1′ at line 1: RELEASE SAVEPOINT active_record_1

RELEASE SAVEPOINT is for Mysql 5.x

It is also described here http://groups.google.com/group/rubyonrails-talk/browse_thread/thread/be0bece7cdf052fa?fwc=1

I get it resolved when digging into the activerecord code :
ActiveRecord::ConnectionAdapters::AbstractAdapter defines release_savepoint method.

To get around with this, just add the belowing patch after Rails was loaded (at the bottom of your config/environment.rb for instance)

# As of mysql 4.x does not support "RELEASE SAVEPOINT" statement
if ActiveRecord::Base.connection.instance_variable_get("@connection").get_server_info < '5.0'
  ActiveRecord::ConnectionAdapters::MysqlAdapter.class_eval do
    # Unset release savepoint method 
    def release_savepoint
    end
  end
end

Hope that this can help !

gettext 2.0.4 and rails 2.3.4

Hallelujah — Thu, 08 Oct 2009 08:09:04 +0000

Rails 2.3.4 broke gettext_activerecord 2.0.4

Well I did not test other gems of the mutoh gettext set of libraries but here is the gulty code that breaks rails.
Since Activerecord::Errors changed its implementation a bit, an error like this is raised :

NoMethodError: undefined method `gsub' for #
        from /home/hallelujah/Jail/lib/ruby/gems/1.9.1/gems/gettext_activerecord-2.0.4/lib/gettext_activerecord/validations.rb:165:in `localize_error_message'
        from /home/hallelujah/Jail/lib/ruby/gems/1.9.1/gems/gettext_activerecord-2.0.4/lib/gettext_activerecord/validations.rb:112:in `block (2 levels) in each_with_gettext_activerecord'
        from /home/hallelujah/Jail/lib/ruby/gems/1.9.1/gems/gettext_activerecord-2.0.4/lib/gettext_activerecord/validations.rb:112:in `each'
        from /home/hallelujah/Jail/lib/ruby/gems/1.9.1/gems/gettext_activerecord-2.0.4/lib/gettext_activerecord/validations.rb:112:in `block in each_with_gettext_activerecord'
        from /home/hallelujah/Jail/lib/ruby/gems/1.9.1/gems/gettext_activerecord-2.0.4/lib/gettext_activerecord/validations.rb:112:in `each_key'
        from /home/hallelujah/Jail/lib/ruby/gems/1.9.1/gems/gettext_activerecord-2.0.4/lib/gettext_activerecord/validations.rb:112:in `each_with_gettext_activerecord'

You can add this piece of code after your gems and rails are loaded (e.g at the bottom of config/environment.rb )

module ActiveRecord
  class Errors
    def localize_error_message_with_patch(attr,obj, append_field)
      obj = obj.respond_to?(:message) ? obj.message : obj
      localize_error_message_without_patch(attr,obj,append_field)
    end
    alias_method_chain :localize_error_message, :patch
  end
end

I think I will patch gettext_activerecord and the muto gettext set of library to fit in rails 2.3.4
Maybe I may keep an eye on Rails 3.0 development.

Ordered Hash by keys

Hallelujah — Fri, 02 Oct 2009 09:15:50 +0000

Recently, I have to implement my own Hash sorting method. Not really with Hash but with ActiveSupport::OrderedHash

ActiveSupport::OrderedHash

Hash

ActiveSupport::OrderedHash

Arrray

I would like to sort with keys only, not with an array [key, value]

Ok no matter, I implemented my own new SimpleOrderedHash :

require 'active_support/ordered_hash'
class SimpleOrderedHash < ActiveSupport::OrderedHash
 
  # Lets reimplement sort method
  def sort(&block)
    h = self.dup
    h.sort!(&block)
    h
  end
 
  # Lets implement sort! method
  # It uses @keys variable to do the sorting
  def sort!(&block)
    @keys.sort!(&block)
    sync_keys!
    self
  end
 
  # A fancy inspect   
  def inspect
    "#<#{self.class.name} #{Hash.instance_method(:inspect).bind(self).call}>"
  end
end

You can now use it like that :

h = SimpleOrderedHash.new
h.merge!({'second' => 1, 'first' => 5, 'third' => 2.5})
=> #2.5, "second"=>1, "first"=>5}>
 
# sort return a SimpleOrderedHash
result = h.sort do |a,b|
  h[a] <=> h[b]
end
=> #2.5, "second"=>1, "first"=>5}>
 
# and order as I wanted
result.each{ |k,v| puts v }
1
2.5
5
=> ["second", "third", "first"]
 
# sort! change internally the order of a SimpleOrderedHash
h.sort! do |a,b|
  h[b] <=> h[a]
end
h.each{ |k,v| puts v }
5
2.5
1
=> ["first", "third", "second"]

Wake up with Amarok and Kalarm ( or cron ) and qdbus

Hallelujah — Thu, 24 Sep 2009 10:50:10 +0000

Well it is not ruby tip. Just a Linux and KDE tip.

I am playing with dbus and wonder if I can wake up with kalarm and amarok under KDE.
The answer is YES!!!

PS : I plan to use ruby implementation of D-Bus and make some apps with it.
let see if I have time for that …
I see that ruby-dbus project is not very active but if you have information about implementations of dbus, please leave a comment or send me an e-mail.

# ! /bin/bash
 
# Variable declaration
 
interval=20
increment=10
volume=30
volumemax=100
 
# Body of the script
 
amarok # Launch Amarok application
qdbus org.kde.amarok /Player Stop #Stop amarok
qdbus org.kde.amarok /Player VolumeSet $volume #Set the volume to initial value of $volume
qdbus org.kde.amarok /Player Play # Play some music
 
while [ "$volume" -lt "$volumemax" ] ; do
 
qdbus org.kde.amarok /Player VolumeSet $volume # Set the volume
 
volume=$(expr $volume + $increment) # Increase volume variable
 
sleep $interval # Wait 20 seconds
 
done 
 
qdbus org.kde.amarok /Player VolumeSet $volumemax # Set volume to its maximum

You can just save this code to a file named amarokalarm.sh and add it to kalarm.

I think you can execute this file with a cron job (DON’T FORGET to add environment variable DISPLAY=:0.0 )

Inspectable accessors

Hallelujah — Wed, 23 Sep 2009 15:49:46 +0000

Hey, it’s been a while I posted here.

So what’s the purpose ? I commonly use script/console to debug my rails applications. Today I wanted to see the values of my custom attributes model without typing model.custom_attribute. So I took a look at ActiveRecord::Base#inspect method. and the default inspect method shows me database fields. Well, let’s do some work to inspect custom attributes.
Say you have a users table with some fields : login,name,encrypted_password.

class User < ActiveRecord::Base
  attr_accessor :heroic_action
end

superman = User.find(1).inspect
superman.heroic_action = "Save the widow and the orphan"
pp superman.inspect
"#Superman",  name: "Clark Kent",
          encrypted_password: "da39a3ee5e6b4b0d3255bfef95601890afd80709">"

Well I also want to know what heroic_action is superman doing. So i have to overwrite inspect method but I would like a DRY solution. That’s why I wrote this code :

EDIT: Just a small change to have inheritance work.

require 'active_support/core_ext/class'
 
module InspectableAttributes
 
  def self.included(base)
    base.class_inheritable_array :inspectable_attributes , :instance_writer => false
    base.extend(ClassMethods)
    base.inspectable_attributes = []
    base.class_eval do 
 
      def inspect
        inspected_values = respond_to?(:attributes_before_type_cast) ? attributes_before_type_cast.map{|k,v| "#{k.to_s}:  #{v.inspect}" } : []
        inspected_values.concat(self.class.inspectable_attributes.map { |attr| "#{attr}: #{send(attr).inspect}" })
        "#<#{self.class.name} #{inspected_values.join(', ')}>"
      end
 
    end
  end
 
  module ClassMethods
    def inspectable_attr_accessor(*args)
      attr_accessor(*args)
      self.inspectable_attributes |= args.map(&:to_s)
    end
  end
 
end

class User < ActiveRecord::Base
  include InspectableAttributes
  inspectable_attr_accessor :heroic_action
end

That’s what I was looking for !!!

superman = User.find(1).inspect
superman.heroic_action = "Save the widow and the orphan"
pp superman.inspect
"#Superman",  name: "Clark Kent",
             encrypted_password: "da39a3ee5e6b4b0d3255bfef95601890afd80709",
             heroic_action: "Save the widow and the orphan">"

Note that this code can be used in any ruby code requiring ‘active_support/core_ext/class’.

Blocks are Proc : Les procédures Proc et les blocks en ruby.

Hallelujah — Fri, 24 Jul 2009 18:01:11 +0000

( For non-french readers : I am not giving up writing in english … Read the next post! )

Si vous venez d’un autre langage, le terme procédure (associé au terme fonction) doit vous dire quelque chose. Vaguement ….

Allez quelques connaissances (méconnaissances) tirées de ma mémoire pour poser les bases.

Par exemple, en PHP il existe deux types de fonctions. Les fonctions natives (built-in) et les fonctions “codées” par l’utilisateur.
Ces dernières se séparent en deux types : les fonctions et les procédures.

La différence entre les deux ? Une procédure est un groupe d’instructions qui ne renvoie pas de valeur. Une fonction est une procédure qui renvoie une valeur.

Et ruby dans tout ça ??

C’est complètement différent et je dirai même plus les procédures Ruby sont très éloignés des procédures PHP. En ruby il n’y a que des objets (les méthodes sont des objets) et les méthodes renvoient toujours une valeur.
Vous avez déjà vu ou même codé des choses comme ceci :

[1,2,3,4,5,6].each do |nb|
  # Un code quelconque : des instructions ...
end

C’ette méthode est native à Enumerable (module que la classe Array inclut)
La méthode Array#each prend 0 paramètre mais un block. Le block est tout ce qui se trouve entre do et end.
On pourrait le représenter en Ruby comme ceci :

def each(&block)
  # Un truc compliqué à écrire en ruby
end

Ne vous y trompez pas “&block” n’est pas un argument. C’est la notation ruby pour dire que la méthode each s’accompagne obligatoirement d’un block.

Autre exemple :

class Bar
 
  def my_proc(&procedure)
     @foo_proc = procedure
  end
 
  def recall
    @foo_proc.call
  end
end
 
bar = Bar.new
bar.my_proc do
# Pas de code
end
 #=> #

Il se trouve que la procédure est une instance de la classe Proc.
Sans trop de surprise mêmes les procédures sont des objets. Et oui, en ruby tout est objet.

Quel est l’intérêt me direz-vous?

Cela change tout !!! En PHP les prcoédures sont codées en dur, en ruby on peut générer à la volée des suites d’instructions sans pour autant avoir à implémenter une méthode !!!

Illustration :

On sait que les blocks sont des instances de la classe Proc. La solution est facile, il suffit de créer des instances de Proc et les passer comme blocks d’une méthode acceptant un block.

p1 = Proc.new do
 puts "Je suis p1"
end
 
p2 = Proc.new do
  puts "Je suis p2"
end
 
bar = Bar.new
bar.my_proc(&p1)
# Je suis p1
#=> nil
bar.foo_proc 
#=> #
 
bar.recall
# Je suis p1
#=> nil
 
bar.my_proc(&p2)
# Je suis p2
#=> #
 
bar.recall
# Je suis p2
#=> nil
 
bar2 = Bar.new
bar2.my_proc(&p2)
# Je suis p2
#=> #
 
bar2.instance_eval("@foo_proc") == bar.instance_eval("@foo_proc") 
#=> true

Vous avez compris l’intérêt? Les blocks sont bien des suites d’instructions mais plus que cela, ce sont des objets !!! L’illustration précédente montre qu’on peut partager des suites d’instructions entre différents objets, générer ces instructions dynamiquement !

En route pour la méta-programmation avec Ruby !!!