<%= simple_format @article.body %>
<%# Partial pour les commentaires %>
<%= render @comments %>
```
Le flux typique : la requête arrive au Router, qui dispatche vers le Controller approprié. Le Controller interagit avec le Model pour récupérer ou modifier les données, puis passe ces données à la View pour le rendu HTML.
### Question 2 : Qu'est-ce qu'Active Record et comment fonctionne l'ORM Rails ?
Active Record est l'ORM (Object-Relational Mapping) de Rails qui implémente le pattern Active Record. Chaque classe Model représente une table de base de données, et chaque instance représente une ligne.
```ruby
# app/models/user.rb
# Active Record mappe automatiquement les colonnes aux attributs
class User < ApplicationRecord
# La table 'users' est automatiquement associée
# Colonnes: id, email, name, created_at, updated_at
has_secure_password # BCrypt pour le mot de passe
has_many :articles, foreign_key: :author_id
has_one :profile, dependent: :destroy
has_and_belongs_to_many :roles
# Validations
validates :email, presence: true,
uniqueness: { case_sensitive: false },
format: { with: URI::MailTo::EMAIL_REGEXP }
# Callbacks
before_save :normalize_email
# Méthodes de classe pour les requêtes
def self.admins
joins(:roles).where(roles: { name: 'admin' })
end
private
def normalize_email
self.email = email.downcase.strip
end
end
```
```ruby
# Exemples de requêtes Active Record
# Console Rails ou dans un service
# Création
user = User.create!(email: 'dev@example.com', name: 'Alice', password: 'secret123')
# Lecture avec conditions
active_users = User.where(active: true).order(:name)
user = User.find_by(email: 'dev@example.com')
# Requêtes chaînées (lazy evaluation)
recent_admins = User.admins
.where('created_at > ?', 1.month.ago)
.includes(:profile)
.limit(10)
# N+1 prevention avec eager loading
articles = Article.includes(:author, :comments).published
# Mise à jour
user.update!(name: 'Alice Martin')
# Transactions
User.transaction do
user.debit_balance!(100)
recipient.credit_balance!(100)
Payment.create!(from: user, to: recipient, amount: 100)
end
```
Active Record convertit les méthodes Ruby en requêtes SQL optimisées. Les méthodes comme `where`, `joins`, `includes` sont paresseuses (lazy) - la requête n'est exécutée qu'au moment de l'itération ou de l'appel à `to_a`.
### Question 3 : Expliquez le système de migrations Rails
Les migrations permettent de versionner le schéma de base de données avec Ruby. Elles sont réversibles et permettent une évolution contrôlée de la structure de données.
```ruby
# db/migrate/20260203100000_create_products.rb
# Migration pour créer une table
class CreateProducts < ActiveRecord::Migration[7.1]
def change
create_table :products do |t|
t.string :name, null: false
t.text :description
t.decimal :price, precision: 10, scale: 2, null: false
t.integer :stock_quantity, default: 0
t.references :category, null: false, foreign_key: true
t.boolean :active, default: true
t.timestamps # created_at et updated_at automatiques
end
# Index pour les performances
add_index :products, :name
add_index :products, [:category_id, :active]
end
end
```
```ruby
# db/migrate/20260203110000_add_slug_to_products.rb
# Migration pour modifier une table existante
class AddSlugToProducts < ActiveRecord::Migration[7.1]
def change
add_column :products, :slug, :string
add_index :products, :slug, unique: true
# Remplir les slugs existants
reversible do |dir|
dir.up do
Product.find_each do |product|
product.update_column(:slug, product.name.parameterize)
end
end
end
# Rendre non-nullable après remplissage
change_column_null :products, :slug, false
end
end
```
```bash
# Commandes de migration essentielles
rails db:migrate # Exécuter les migrations pending
rails db:rollback # Annuler la dernière migration
rails db:rollback STEP=3 # Annuler les 3 dernières migrations
rails db:migrate:status # Voir le statut des migrations
rails db:seed # Exécuter db/seeds.rb
rails db:reset # Drop, create, migrate, seed
```
Les migrations doivent être réversibles. La méthode `change` est intelligente et peut inverser automatiquement les opérations courantes. Pour les cas complexes, utiliser `up` et `down` séparément.
## Active Record Avancé
### Question 4 : Comment optimiser les requêtes N+1 dans Rails ?
Le problème N+1 survient quand une requête initiale est suivie de N requêtes additionnelles pour charger les associations. Rails propose plusieurs méthodes d'eager loading pour résoudre ce problème.
```ruby
# app/controllers/orders_controller.rb
class OrdersController < ApplicationController
def index
# ❌ PROBLÈME N+1 : 1 requête + N requêtes par order
# @orders = Order.all
# Dans la view : order.user.name génère une requête par order
# ✅ SOLUTION avec includes (eager loading)
@orders = Order.includes(:user, :items)
.where(status: 'completed')
.order(created_at: :desc)
# Génère seulement 3 requêtes total
end
def show
# includes : charge les associations séparément (2-3 requêtes)
@order = Order.includes(items: :product).find(params[:id])
# preload : force le chargement séparé
@order = Order.preload(:items, :user).find(params[:id])
# eager_load : force un LEFT OUTER JOIN (1 requête)
@order = Order.eager_load(:items).find(params[:id])
end
end
```
```ruby
# app/models/order.rb
class Order < ApplicationRecord
belongs_to :user
has_many :items, class_name: 'OrderItem'
has_many :products, through: :items
# Scope avec includes par défaut
scope :with_details, -> { includes(:user, items: :product) }
# Counter cache pour éviter COUNT queries
# Nécessite: add_column :users, :orders_count, :integer, default: 0
belongs_to :user, counter_cache: true
end
```
```ruby
# Détection N+1 avec Bullet gem (development)
# config/environments/development.rb
config.after_initialize do
Bullet.enable = true
Bullet.alert = true
Bullet.bullet_logger = true
Bullet.rails_logger = true
end
# Bullet affichera des alertes quand :
# - Une requête N+1 est détectée
# - Un eager loading inutile est présent
# - Un counter cache devrait être utilisé
```
La règle : utiliser `includes` par défaut (Rails choisit la stratégie optimale), `preload` quand on veut forcer des requêtes séparées, `eager_load` quand on filtre sur les associations.
### Question 5 : Expliquez les scopes et les query objects dans Rails
Les scopes encapsulent des conditions de requête réutilisables. Pour des requêtes complexes, les Query Objects offrent une meilleure organisation et testabilité.
```ruby
# app/models/product.rb
class Product < ApplicationRecord
# Scopes simples
scope :active, -> { where(active: true) }
scope :in_stock, -> { where('stock_quantity > 0') }
scope :featured, -> { where(featured: true) }
# Scopes avec paramètres
scope :cheaper_than, ->(price) { where('price < ?', price) }
scope :in_category, ->(category) { where(category: category) }
# Scopes chaînables
scope :available, -> { active.in_stock }
# Scope avec jointures
scope :with_recent_orders, -> {
joins(:order_items)
.where('order_items.created_at > ?', 30.days.ago)
.distinct
}
# Scope avec sous-requête
scope :bestsellers, -> {
where(id: OrderItem.group(:product_id)
.order('COUNT(*) DESC')
.limit(10)
.select(:product_id))
}
end
```
```ruby
# app/queries/products_search_query.rb
# Query Object pour recherches complexes
class ProductsSearchQuery
def initialize(relation = Product.all)
@relation = relation
end
def call(params)
@relation = filter_by_category(params[:category])
@relation = filter_by_price_range(params[:min_price], params[:max_price])
@relation = filter_by_search(params[:q])
@relation = apply_sorting(params[:sort])
@relation
end
private
def filter_by_category(category)
return @relation if category.blank?
@relation.where(category_id: category)
end
def filter_by_price_range(min, max)
@relation = @relation.where('price >= ?', min) if min.present?
@relation = @relation.where('price <= ?', max) if max.present?
@relation
end
def filter_by_search(query)
return @relation if query.blank?
@relation.where('name ILIKE ? OR description ILIKE ?',
"%#{query}%", "%#{query}%")
end
def apply_sorting(sort)
case sort
when 'price_asc' then @relation.order(price: :asc)
when 'price_desc' then @relation.order(price: :desc)
when 'newest' then @relation.order(created_at: :desc)
else @relation.order(:name)
end
end
end
# Utilisation dans le controller
@products = ProductsSearchQuery.new(Product.active).call(params)
```
Les scopes sont parfaits pour des conditions simples et réutilisables. Les Query Objects conviennent aux recherches complexes avec plusieurs filtres optionnels et une logique de composition.
## Routing et Controllers
### Question 6 : Comment fonctionne le routing RESTful dans Rails ?
Rails encourage les routes RESTful qui mappent les verbes HTTP aux actions CRUD. Le router traduit les URLs en appels de controller spécifiques.
```ruby
# config/routes.rb
Rails.application.routes.draw do
# Routes RESTful standard (7 actions)
resources :articles do
# Routes imbriquées
resources :comments, only: [:create, :destroy]
# Routes membres (agissent sur une instance)
member do
post :publish
delete :archive
end
# Routes collection (agissent sur la collection)
collection do
get :drafts
get :search
end
end
# Routes API avec namespace
namespace :api do
namespace :v1 do
resources :products, only: [:index, :show, :create, :update] do
resources :reviews, shallow: true
end
end
end
# Route personnalisée
get 'dashboard', to: 'dashboard#index'
# Contraintes sur les routes
constraints(SubdomainConstraint.new) do
resources :admin_settings
end
# Route racine
root 'home#index'
end
```
```bash
# rails routes - Affiche toutes les routes générées
#
# Verb URI Pattern Controller#Action
# GET /articles articles#index
# POST /articles articles#create
# GET /articles/new articles#new
# GET /articles/:id/edit articles#edit
# GET /articles/:id articles#show
# PATCH /articles/:id articles#update
# DELETE /articles/:id articles#destroy
# POST /articles/:id/publish articles#publish
# GET /articles/drafts articles#drafts
```
Les helpers de route générés (`article_path(@article)`, `new_article_path`) permettent de référencer les URLs de manière dynamique et maintenable.
### Question 7 : Expliquez les callbacks et filters dans les controllers
Les callbacks (before_action, after_action, around_action) permettent d'exécuter du code avant, après ou autour des actions du controller.
```ruby
# app/controllers/application_controller.rb
class ApplicationController < ActionController::Base
# Protection CSRF activée par défaut
protect_from_forgery with: :exception
# Callback global pour l'authentification
before_action :authenticate_user!
# Gestion des erreurs globale
rescue_from ActiveRecord::RecordNotFound, with: :not_found
rescue_from ActionController::ParameterMissing, with: :bad_request
private
def not_found
render json: { error: 'Resource not found' }, status: :not_found
end
def bad_request(exception)
render json: { error: exception.message }, status: :bad_request
end
end
```
```ruby
# app/controllers/admin/products_controller.rb
class Admin::ProductsController < ApplicationController
# Callbacks avec options
before_action :require_admin
before_action :set_product, only: [:show, :edit, :update, :destroy]
after_action :log_activity, only: [:create, :update, :destroy]
# Callback conditionnel
before_action :check_stock, only: [:update], if: :stock_changed?
def create
@product = Product.new(product_params)
if @product.save
redirect_to [:admin, @product], notice: 'Produit créé.'
else
render :new, status: :unprocessable_entity
end
end
def update
if @product.update(product_params)
redirect_to [:admin, @product], notice: 'Produit mis à jour.'
else
render :edit, status: :unprocessable_entity
end
end
private
def require_admin
redirect_to root_path unless current_user&.admin?
end
def set_product
@product = Product.find(params[:id])
end
def stock_changed?
params[:product][:stock_quantity].present?
end
def log_activity
ActivityLog.create!(
user: current_user,
action: action_name,
resource: @product
)
end
def product_params
params.require(:product).permit(:name, :price, :description, :stock_quantity)
end
end
```
Les callbacks s'exécutent dans l'ordre de déclaration. Utiliser `skip_before_action` dans les sous-classes pour désactiver un callback hérité. Éviter les callbacks avec trop de logique métier - préférer les Service Objects.
## Services et Architecture
### Question 8 : Comment implémenter des Service Objects dans Rails ?
Les Service Objects encapsulent la logique métier complexe qui ne appartient ni au Model ni au Controller. Ils améliorent la testabilité et respectent le principe de responsabilité unique.
```ruby
# app/services/order_processor.rb
# Service Object avec interface standardisée
class OrderProcessor
def initialize(order, payment_method:)
@order = order
@payment_method = payment_method
end
def call
return failure('Order already processed') if @order.processed?
ActiveRecord::Base.transaction do
validate_stock!
process_payment!
update_inventory!
send_confirmation!
@order.update!(status: 'completed', processed_at: Time.current)
end
success(@order)
rescue PaymentError => e
failure("Payment failed: #{e.message}")
rescue InsufficientStockError => e
failure("Stock insufficient: #{e.message}")
end
private
def validate_stock!
@order.items.each do |item|
unless item.product.stock_quantity >= item.quantity
raise InsufficientStockError, item.product.name
end
end
end
def process_payment!
result = PaymentGateway.charge(
amount: @order.total,
method: @payment_method,
description: "Order ##{@order.id}"
)
raise PaymentError, result.error unless result.success?
@order.update!(payment_reference: result.transaction_id)
end
def update_inventory!
@order.items.each do |item|
item.product.decrement!(:stock_quantity, item.quantity)
end
end
def send_confirmation!
OrderMailer.confirmation(@order).deliver_later
end
def success(data)
Result.new(success: true, data: data)
end
def failure(error)
Result.new(success: false, error: error)
end
Result = Struct.new(:success, :data, :error, keyword_init: true) do
def success? = success
def failure? = !success
end
end
```
```ruby
# app/controllers/orders_controller.rb
class OrdersController < ApplicationController
def create
@order = current_user.orders.build(order_params)
if @order.save
result = OrderProcessor.new(@order, payment_method: params[:payment_method]).call
if result.success?
redirect_to @order, notice: 'Commande confirmée!'
else
@order.update!(status: 'payment_failed')
flash.now[:alert] = result.error
render :new, status: :unprocessable_entity
end
else
render :new, status: :unprocessable_entity
end
end
end
```
Le pattern Service Object suit une convention simple : une classe, une responsabilité, une méthode publique `call`. Le retour d'un objet Result permet une gestion propre des succès et échecs.
### Question 9 : Expliquez les Concerns dans Rails
Les Concerns permettent d'extraire et partager du code entre Models ou Controllers. Ils utilisent `ActiveSupport::Concern` pour une syntaxe propre d'inclusion.
```ruby
# app/models/concerns/sluggable.rb
# Concern réutilisable pour générer des slugs
module Sluggable
extend ActiveSupport::Concern
included do
# Code exécuté à l'inclusion
before_validation :generate_slug, if: :should_generate_slug?
validates :slug, presence: true, uniqueness: true
end
# Méthodes de classe
class_methods do
def find_by_slug!(slug)
find_by!(slug: slug)
end
def sluggable_source(column = :title)
@sluggable_source = column
end
def sluggable_source_column
@sluggable_source || :title
end
end
# Méthodes d'instance
def to_param
slug
end
private
def should_generate_slug?
slug.blank? || send("#{self.class.sluggable_source_column}_changed?")
end
def generate_slug
source = send(self.class.sluggable_source_column)
return if source.blank?
base_slug = source.parameterize
self.slug = unique_slug(base_slug)
end
def unique_slug(base)
slug = base
counter = 1
while self.class.where(slug: slug).where.not(id: id).exists?
slug = "#{base}-#{counter}"
counter += 1
end
slug
end
end
```
```ruby
# app/models/article.rb
class Article < ApplicationRecord
include Sluggable
sluggable_source :title # Optionnel, :title par défaut
end
# app/models/product.rb
class Product < ApplicationRecord
include Sluggable
sluggable_source :name
end
```
```ruby
# app/controllers/concerns/pagination.rb
# Concern pour les controllers
module Pagination
extend ActiveSupport::Concern
included do
helper_method :page_param, :per_page_param
end
private
def paginate(relation)
relation.page(page_param).per(per_page_param)
end
def page_param
params[:page]&.to_i || 1
end
def per_page_param
[params[:per_page]&.to_i || 25, 100].min
end
end
```
Les Concerns sont utiles pour le code véritablement partagé. Éviter de créer des Concerns pour simplement "raccourcir" un Model - cela masque la complexité sans la réduire.
## Tests avec RSpec
### Question 10 : Comment structurer les tests RSpec dans Rails ?
RSpec est le framework de test standard pour Rails. Une bonne structure de tests inclut les specs de Models, Controllers, Services, et les tests d'intégration.
```ruby
# spec/models/user_spec.rb
require 'rails_helper'
RSpec.describe User, type: :model do
# Factories avec FactoryBot
let(:user) { build(:user) }
let(:admin) { build(:user, :admin) }
describe 'validations' do
it { is_expected.to validate_presence_of(:email) }
it { is_expected.to validate_uniqueness_of(:email).case_insensitive }
it 'validates email format' do
user.email = 'invalid'
expect(user).not_to be_valid
expect(user.errors[:email]).to include('is invalid')
end
end
describe 'associations' do
it { is_expected.to have_many(:articles).dependent(:destroy) }
it { is_expected.to have_one(:profile) }
it { is_expected.to belong_to(:organization).optional }
end
describe '#full_name' do
it 'returns first and last name combined' do
user = build(:user, first_name: 'John', last_name: 'Doe')
expect(user.full_name).to eq('John Doe')
end
it 'handles missing last name' do
user = build(:user, first_name: 'John', last_name: nil)
expect(user.full_name).to eq('John')
end
end
describe '.active' do
it 'returns only active users' do
active = create(:user, active: true)
inactive = create(:user, active: false)
expect(User.active).to include(active)
expect(User.active).not_to include(inactive)
end
end
end
```
```ruby
# spec/services/order_processor_spec.rb
require 'rails_helper'
RSpec.describe OrderProcessor do
let(:user) { create(:user) }
let(:product) { create(:product, stock_quantity: 10, price: 100) }
let(:order) { create(:order, user: user, items: [build(:order_item, product: product, quantity: 2)]) }
subject { described_class.new(order, payment_method: 'card') }
describe '#call' do
context 'when order is valid' do
before do
allow(PaymentGateway).to receive(:charge).and_return(
OpenStruct.new(success?: true, transaction_id: 'txn_123')
)
end
it 'processes the order successfully' do
result = subject.call
expect(result).to be_success
expect(order.reload.status).to eq('completed')
end
it 'decrements product stock' do
expect { subject.call }.to change { product.reload.stock_quantity }.by(-2)
end
it 'sends confirmation email' do
expect { subject.call }
.to have_enqueued_mail(OrderMailer, :confirmation)
.with(order)
end
end
context 'when payment fails' do
before do
allow(PaymentGateway).to receive(:charge).and_return(
OpenStruct.new(success?: false, error: 'Card declined')
)
end
it 'returns failure result' do
result = subject.call
expect(result).to be_failure
expect(result.error).to include('Card declined')
end
it 'does not update order status' do
expect { subject.call }.not_to change { order.reload.status }
end
end
end
end
```
```ruby
# spec/requests/api/v1/products_spec.rb
require 'rails_helper'
RSpec.describe 'API V1 Products', type: :request do
let(:user) { create(:user) }
let(:headers) { { 'Authorization' => "Bearer #{user.api_token}" } }
describe 'GET /api/v1/products' do
let!(:products) { create_list(:product, 3, :active) }
it 'returns list of products' do
get '/api/v1/products', headers: headers
expect(response).to have_http_status(:ok)
expect(json_response['data'].size).to eq(3)
end
it 'filters by category' do
category = create(:category)
categorized = create(:product, category: category)
get '/api/v1/products', params: { category_id: category.id }, headers: headers
expect(json_response['data'].map { |p| p['id'] }).to eq([categorized.id])
end
end
describe 'POST /api/v1/products' do
let(:valid_params) do
{ product: { name: 'New Product', price: 99.99, category_id: create(:category).id } }
end
it 'creates a new product' do
expect {
post '/api/v1/products', params: valid_params, headers: headers
}.to change(Product, :count).by(1)
expect(response).to have_http_status(:created)
end
end
end
```
Les bonnes pratiques : utiliser `let` pour les données, `describe` pour les méthodes/contextes, `context` pour les conditions, et `it` pour les assertions spécifiques. Un test doit tester une seule chose.
### Question 11 : Comment utiliser les Factories avec FactoryBot ?
FactoryBot permet de créer des données de test de manière déclarative et maintenable. Les factories remplacent les fixtures statiques.
```ruby
# spec/factories/users.rb
FactoryBot.define do
factory :user do
# Séquences pour l'unicité
sequence(:email) { |n| "user#{n}@example.com" }
first_name { Faker::Name.first_name }
last_name { Faker::Name.last_name }
password { 'password123' }
confirmed_at { Time.current }
# Traits pour les variations
trait :admin do
role { 'admin' }
after(:create) do |user|
user.permissions.create!(name: 'admin_access')
end
end
trait :unconfirmed do
confirmed_at { nil }
end
trait :with_profile do
after(:create) do |user|
create(:profile, user: user)
end
end
trait :with_articles do
transient do
articles_count { 3 }
end
after(:create) do |user, evaluator|
create_list(:article, evaluator.articles_count, author: user)
end
end
# Factory héritée
factory :admin_user do
admin
with_profile
end
end
end
```
```ruby
# spec/factories/orders.rb
FactoryBot.define do
factory :order do
user
status { 'pending' }
trait :with_items do
transient do
items_count { 2 }
end
after(:create) do |order, evaluator|
create_list(:order_item, evaluator.items_count, order: order)
order.recalculate_total!
end
end
trait :completed do
status { 'completed' }
processed_at { Time.current }
with_items
end
trait :high_value do
after(:create) do |order|
create(:order_item, order: order, quantity: 10, unit_price: 500)
order.recalculate_total!
end
end
end
end
```
```ruby
# Utilisation dans les tests
RSpec.describe OrderProcessor do
# build : instance non sauvegardée
let(:user) { build(:user) }
# create : instance sauvegardée en DB
let(:order) { create(:order, :with_items, user: user) }
# create_list : plusieurs instances
let(:products) { create_list(:product, 5) }
# Combinaison de traits
let(:admin) { create(:user, :admin, :with_profile) }
# Override d'attributs
let(:expensive_order) { create(:order, :with_items, items_count: 10) }
# build_stubbed : plus rapide, pour les tests unitaires
let(:stubbed_user) { build_stubbed(:user) }
end
```
Préférer `build` ou `build_stubbed` à `create` quand la persistence n'est pas nécessaire - cela accélère significativement les tests.
## Background Jobs
### Question 12 : Comment utiliser Active Job et Sidekiq dans Rails ?
Active Job fournit une interface unifiée pour les background jobs, indépendamment du backend (Sidekiq, Resque, etc.). Sidekiq est le choix populaire pour sa performance avec Redis.
```ruby
# app/jobs/process_order_job.rb
class ProcessOrderJob < ApplicationJob
queue_as :default
# Retry configuration
retry_on ActiveRecord::Deadlocked, wait: 5.seconds, attempts: 3
retry_on Net::OpenTimeout, wait: :polynomially_longer, attempts: 10
discard_on ActiveJob::DeserializationError
# Sidekiq options (si Sidekiq backend)
sidekiq_options retry: 5, backtrace: true
def perform(order_id)
order = Order.find(order_id)
OrderProcessor.new(order).call
rescue ActiveRecord::RecordNotFound
# Order supprimée entre l'enqueue et l'exécution
Rails.logger.warn("Order #{order_id} not found, skipping job")
end
end
```
```ruby
# app/jobs/batch_email_job.rb
class BatchEmailJob < ApplicationJob
queue_as :mailers
# Rate limiting avec Sidekiq Enterprise ou gem throttle
sidekiq_options throttle: { threshold: 100, period: 1.minute }
def perform(user_ids, template_id)
template = EmailTemplate.find(template_id)
User.where(id: user_ids).find_each do |user|
UserMailer.custom_email(user, template).deliver_later
end
end
end
```
```ruby
# Enqueuing jobs
# Immédiat
ProcessOrderJob.perform_later(order.id)
# Différé
ProcessOrderJob.set(wait: 5.minutes).perform_later(order.id)
# À une heure spécifique
ProcessOrderJob.set(wait_until: Date.tomorrow.noon).perform_later(order.id)
# Queue spécifique
ProcessOrderJob.set(queue: :critical).perform_later(order.id)
# Synchrone (pour les tests ou debugging)
ProcessOrderJob.perform_now(order.id)
```
```ruby
# config/sidekiq.yml
:concurrency: 10
:queues:
- [critical, 3] # Priorité haute, poids 3
- [default, 2] # Priorité moyenne, poids 2
- [mailers, 1] # Priorité basse, poids 1
- [low, 1]
:schedule:
cleanup_job:
cron: '0 3 * * *' # Tous les jours à 3h
class: CleanupJob
```
Active Job abstrait le backend, mais accéder aux fonctionnalités spécifiques (batches, rate limiting) nécessite souvent de coupler au backend choisi.
## API Development
### Question 13 : Comment construire une API RESTful avec Rails ?
Rails facilite la construction d'APIs JSON avec les Controllers API-only et les serializers. Une bonne API est versionnée, documentée et sécurisée.
```ruby
# app/controllers/api/v1/base_controller.rb
module Api
module V1
class BaseController < ActionController::API
include ActionController::HttpAuthentication::Token::ControllerMethods
before_action :authenticate_token!
rescue_from ActiveRecord::RecordNotFound, with: :not_found
rescue_from ActiveRecord::RecordInvalid, with: :unprocessable_entity
rescue_from ActionController::ParameterMissing, with: :bad_request
private
def authenticate_token!
authenticate_or_request_with_http_token do |token, options|
@current_user = User.find_by(api_token: token)
end
end
def current_user
@current_user
end
def not_found(exception)
render json: { error: 'Resource not found', details: exception.message },
status: :not_found
end
def unprocessable_entity(exception)
render json: { error: 'Validation failed', details: exception.record.errors },
status: :unprocessable_entity
end
def bad_request(exception)
render json: { error: 'Bad request', details: exception.message },
status: :bad_request
end
end
end
end
```
```ruby
# app/controllers/api/v1/products_controller.rb
module Api
module V1
class ProductsController < BaseController
before_action :set_product, only: [:show, :update, :destroy]
def index
@products = Product.active
.includes(:category)
.page(params[:page])
.per(params[:per_page] || 20)
render json: {
data: ProductSerializer.new(@products).serializable_hash,
meta: pagination_meta(@products)
}
end
def show
render json: ProductSerializer.new(@product, include: [:category, :reviews])
end
def create
@product = Product.new(product_params)
@product.save!
render json: ProductSerializer.new(@product), status: :created
end
def update
@product.update!(product_params)
render json: ProductSerializer.new(@product)
end
def destroy
@product.destroy!
head :no_content
end
private
def set_product
@product = Product.find(params[:id])
end
def product_params
params.require(:product).permit(:name, :description, :price, :category_id)
end
def pagination_meta(collection)
{
current_page: collection.current_page,
total_pages: collection.total_pages,
total_count: collection.total_count
}
end
end
end
end
```
```ruby
# app/serializers/product_serializer.rb
# Avec jsonapi-serializer gem
class ProductSerializer
include JSONAPI::Serializer
attributes :id, :name, :description, :price, :created_at
attribute :formatted_price do |product|
"$#{product.price.to_f.round(2)}"
end
belongs_to :category
has_many :reviews
link :self do |product|
Rails.application.routes.url_helpers.api_v1_product_url(product)
end
end
```
Les bonnes pratiques API : versionner via namespace, utiliser les codes HTTP appropriés, paginer les collections, et fournir des messages d'erreur clairs.
### Question 14 : Comment implémenter l'authentification JWT dans Rails ?
JWT (JSON Web Tokens) est une méthode stateless d'authentification populaire pour les APIs. Le token encode l'identité de l'utilisateur et sa validité.
```ruby
# app/services/jwt_service.rb
class JwtService
SECRET_KEY = Rails.application.credentials.secret_key_base
ALGORITHM = 'HS256'.freeze
class << self
def encode(payload, exp = 24.hours.from_now)
payload[:exp] = exp.to_i
payload[:iat] = Time.current.to_i
JWT.encode(payload, SECRET_KEY, ALGORITHM)
end
def decode(token)
decoded = JWT.decode(token, SECRET_KEY, true, algorithm: ALGORITHM)
HashWithIndifferentAccess.new(decoded.first)
rescue JWT::ExpiredSignature
raise AuthenticationError, 'Token has expired'
rescue JWT::DecodeError
raise AuthenticationError, 'Invalid token'
end
end
end
```
```ruby
# app/controllers/api/v1/auth_controller.rb
module Api
module V1
class AuthController < ActionController::API
def login
user = User.find_by(email: params[:email])
if user&.authenticate(params[:password])
token = JwtService.encode(user_id: user.id)
render json: {
token: token,
user: UserSerializer.new(user),
expires_at: 24.hours.from_now
}
else
render json: { error: 'Invalid credentials' }, status: :unauthorized
end
end
def refresh
token = JwtService.encode(user_id: current_user.id)
render json: { token: token, expires_at: 24.hours.from_now }
end
end
end
end
```
```ruby
# app/controllers/concerns/jwt_authenticatable.rb
module JwtAuthenticatable
extend ActiveSupport::Concern
included do
before_action :authenticate_jwt!
end
private
def authenticate_jwt!
header = request.headers['Authorization']
token = header&.split(' ')&.last
raise AuthenticationError, 'Missing token' unless token
decoded = JwtService.decode(token)
@current_user = User.find(decoded[:user_id])
rescue AuthenticationError => e
render json: { error: e.message }, status: :unauthorized
rescue ActiveRecord::RecordNotFound
render json: { error: 'User not found' }, status: :unauthorized
end
def current_user
@current_user
end
end
```
Pour la production, considérer : refresh tokens, token blacklisting pour logout, et des durées de vie courtes. Des gems comme `devise-jwt` simplifient l'implémentation.
## Caching et Performance
### Question 15 : Comment implémenter le caching dans Rails ?
Rails offre plusieurs niveaux de caching : fragment caching, Russian Doll caching, low-level caching. Le choix dépend du cas d'usage.
```ruby
# config/environments/production.rb
config.action_controller.perform_caching = true
config.cache_store = :redis_cache_store, {
url: ENV['REDIS_URL'],
namespace: 'myapp:cache',
expires_in: 1.day,
race_condition_ttl: 10.seconds
}
```
```erb
<%# app/views/products/index.html.erb %>
<%# Fragment caching avec cache key automatique %>
<% @products.each do |product| %>
<%# Cache basé sur updated_at du produit %>
<% cache product do %>
<%= render product %>
<% end %>
<% end %>
<%# Russian Doll caching - cache imbriqué %>
<% cache ['v1', @category] do %>