La rolls des blogs » metaprogramming

Reloading models in Rails 3.1 when usign Spork and cache_classes = true

Hallelujah — Fri, 13 Jan 2012 23:47:52 +0000

Speeding up you tests with Spork is very common when developping Rails applications.

What Spork do is preloading your application in a server and copies a fork of that server whenever you run tests.

It avoids reloading all the rails stack !! That is great !!!

But the problem I ran into is that I wanted to be able to

reload my application files
and keep cache_classes = true

That is why I like ruby and rails (and great coders there ! ). What I simply did :

Reading and understanding the rails initialize process (especially these lines engine.rb and finisher.rb )
Adding these small pieces of code in my prefork block with Spork trap method
trap eager loading in my prefork block like below

  require 'rails/application'
 
  # Use of https://github.com/sporkrb/spork/wiki/Spork.trap_method-Jujutsu
  Spork.trap_method(Rails::Application, :reload_routes!)
  Spork.trap_method(Rails::Application::RoutesReloader, :reload!)
 
  require 'rails/mongoid'
  Spork.trap_class_method(Rails::Mongoid, :load_models)
 
  # Prevent main application to eager_load in the prefork block (do not load files in autoload_paths)
  Spork.trap_method(Rails::Application, :eager_load!)
 
  # Below this line it is too late...
  require File.expand_path("../../config/environment", __FILE__)
  # Load all railties files
  Rails.application.railties.all { |r| r.eager_load! }

My own benefits : specs runs faster than setting cache_classes = false

You need small explanation of what I’ve done !

  Spork.trap_method(Rails::Application, :eager_load!)
  require File.expand_path("../../config/environment", __FILE__)
  Rails.application.railties.all { |r| r.eager_load! }

First, we prevent Rails::Application to loads files in the application autoload_paths such as app/models, app/controllers etc …

  Spork.trap_method(Rails::Application, :eager_load!)

Second, we load the rails stack :

  require File.expand_path("../../config/environment", __FILE__)

Last, we eager load all the engines :

  Rails.application.railties.all { |r| r.eager_load! }

Doing that we can make change in our models and avoid restarting spork.

Why don’t I just set cache_classes to false ?

Because the ActiveSupport::Dependencies.mechanism is set to :require and not :load

All application files are required and not just loaded (spork required them just after forking, not before).
This trick could resolve some inconsistencies in your application (such as already defined constant and else …)

Rspec 2.x and Fixtures

Hallelujah — Thu, 17 Mar 2011 11:48:40 +0000

Hello,

It’s been a while when I last updated this blog. It seems that Rspec 2 can not use fixtures from Activerecord 2.3.x !

Impossible ? Not really, and thanks to ruby it was possible for me.

Let’s describe the background :

First of all, I had a gem built on jeweler that uses ActiveSupport::TestCase and ActiveRecord::Fixtures exactly implemented like in Rails
But one day, I decided to switch to RSpec (jeweler (1.5.2) uses as of my writing rspec ~> 2.3.0)

The conversion of test_* to “it” syntax was very quick and easy but loading fixtures was not !!!
So here is my implementation if you want to know how can this be possible :

# spec/spec_helper.rb
# .... some stuff ...
 require 'activerecord'
module  MyExtensions
  def self.extended(base)
    class << base # Beginning of Proxy
      def subclass_with_fixtures(*args,&block)
        child = subclass_without_fixtures(*args,&block)
        child.module_eval do
          include ActiveSupport::Callbacks
          define_callbacks :setup, :teardown
          include ActiveRecord::TestFixtures
 
          self.fixture_path = File.expand_path("../db/fixtures",__FILE__)
          self.use_instantiated_fixtures = false
          self.use_transactional_fixtures = true
          self.set_fixture_class :categories => 'Categorie'
 
          def run_in_transaction?
            true
          end
        end
        child
      end # End of method chain subclass_with_fixtures
      alias_method_chain :subclass, :fixtures
    end # End of Proxy
  end # End of extended
end # End of MyExtensions
 
RSpec::Core::ExampleGroup.extend(MyExtensions)
RSpec.configure do |config|
 
  config.after(:each) do
    run_callbacks :teardown, :enumerator => :reverse_each
  end
 
  config.before(:each) do
    run_callbacks :setup
  end
 
end

In my fixtures :

  # spec/db/fixtures/posts.yml
  a_post:
    title: "My first post"

Now when I want to load fixtures :

# spec/post_spec.rb
describe "Post" do
  before(:all) do
   self.class.fixtures :posts
  end
 
  it "should not save without a title" do
     post = posts(:a_post)
    post.title = nil
    post.save.should_not be_true
  end
end

Maybe, a better way can be found … if so please inform me !!!

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.

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.

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 !!!