Retour

5 astuces pratiques pour la console Rails

Série: Café Ruby
Enregistrer
Temps de lecture: 3 min Vues: 178 Niveau: Intermédiaire
1 jour par Franci-lobbie LALANE
Default Post Image
Tags:
#rails #console #active_record #tips #pluck #performance #debug #café_ruby

1) Lancer la console en mode sandbox

Quand tu veux tester une manip sans risquer de salir la base, ajoute --sandbox.
bin/rails console --sandbox

Rails ouvre une transaction autour de ta session. Tu peux créer/modifier ce que tu veux, tout sera rollback à la sortie.
User.create!(email: "test@example.com")
exit # => rollback auto

Tip: pratique aussi pour tester un migration ou un callback sans toucher aux vraies données.

2) Recharger le code sans quitter: reload!

Tu modifies un modèle ou un service pendant que la console tourne ? Pas besoin de quitter.
reload!

Rails vide le cache de Zeitwerk et recharge les classes. Tu peux enchaîner tout de suite:
# avant reload! : la méthode n'existe pas
Article.new.respond_to?(:published_at_human) # => false

reload!

# après : chargée si tu as édité le fichier
Article.new.respond_to?(:published_at_human) # => true

Si un truc reste coincé, tu peux aussi tuer Spring:
bin/spring stop

3) Tester un endpoint sans curl: app.get et les helpers

Depuis la console, tu peux appeler tes routes comme un mini navigateur.
app.get "/status"
app.response.status     # => 200
app.response.media_type # => "application/json"
app.response.body       # => "{...}"

Besoin d'une URL ou d'un helper de vue ?
app.url_helpers.post_path(Post.first)
helpers.number_to_currency(42)

Pratique pour débugger un contrôleur en 30 secondes.

4) Faire taire le bruit SQL (ou l'afficher mieux)

Quand la console spam trop, baisse le niveau de logs:
ActiveRecord::Base.logger.level = :warn  # ou :error

Et pour revenir au niveau par défaut:
ActiveRecord::Base.logger.level = :info

Autre option ponctuelle:
Rails.logger.silence do
  heavy_query
end

5) Eviter de charger 1 million de lignes en RAM

Dans la console, on a vite fait un User.all.each fatal. Préfère ces patterns:
# 5a) Parcourir sans tout charger\ nUser.find_each(batch_size: 1000) { |u| u.touch }

# 5b) Travailler par paquets\ nUser.in_batches(of: 500) { |batch| batch.update_all(active: true) }

# 5c) Récupérer juste les colonnes utiles\ nUser.where(active: true).pluck(:id, :email)

# 5d) Voir la requête générée\ nUser.where(active: true).to_sql

Tu économises RAM, temps et sueur froide.

6) Manipuler les résultats rapidement: pluck, pick, select vs map

Tu veux récupérer des valeurs sans instancier des objets ActiveRecord (et sans exploser la RAM) ? pluck et pick sont tes amis.
pluck – retourne des valeurs Ruby, directement depuis SQL
  • Un attribut
  • User.where(active: true).pluck(:email)
    # => ["a@ex.com", "b@ex.com", ...]
    
  • Plusieurs attributs (renvoie des paires/tuples)
  • User.pluck(:id, :email)
    # => [[1, "a@ex.com"], [2, "b@ex.com"], ...]
    
  • Besoin d'un hash id => email ?
  • User.pluck(:id, :email).to_h
    # => {1=>"a@ex.com", 2=>"b@ex.com", ...}
    
  • Avec distinct, order, limit
  • User.distinct.order(:created_at).limit(10).pluck(:email)
    
  • Pourquoi c'est mieux que map(&:email) ?
    map instancie chaque User en Ruby. pluck fait un SELECT email côté DB et renvoie des valeurs prêtes à l'emploi. C'est plus léger et souvent plus rapide.
pick – la version "un seul enregistrement"
Récupère une ou plusieurs colonnes du premier enregistrement, sans objet AR :
User.where(email: "a@ex.com").pick(:id)
# => 42

User.where(email: "a@ex.com").pick(:id, :created_at)
# => [42, 2025-07-21 10:03:00 +0200]

C'est l'équivalent compact de where(...).limit(1).pluck(...) .first, plus propre que find_by(... )&.id.
select (SQL) vs map (Ruby)
  • select(:id, :email) charge des objets AR mais uniquement avec les colonnes listées. Utile si tu dois appeler des méthodes ensuite.
  • map(&:email) parcourt en Ruby ce qui est déjà en mémoire. Sur de gros volumes, privilégie find_each ou in_batches.
Petits raccourcis utiles
User.ids                  # ≈ User.pluck(:id)
User.where(active: true).pluck(:id, :email).map { |id, mail| { id: id, email: mail } }
user.slice(:id, :email)   # Hash avec seulement ces attributs
User.where(role: :admin).as_json(only: [:id, :email])

Tu as une astuce console fétiche ? Partage-la en commentaire.



Happy coding ! 😄

Laissez un commentaire

Se connecterpour laisser un commentaire.