Rails avec PostgreSQL : guide pratique

Pourquoi Rails avec PostgreSQL : guide pratique ?

Dans un environnement moderne, les développeurs ont besoin d'outils robustes et performants pour construire des applications web évoluées. Rails est une framework Ruby populaire qui a révolutionné la façon de développer des applications web grâce à sa philosophie DRY (Don't Repeat Yourself). PostgreSQL, quant à lui, est un système de gestion de base de données relationnelle (SGBDR) open source connu pour son performance et sa fiabilité. Ensemble, Rails et PostgreSQL forment une combinaison parfaite pour le développement d'applications web modernes.

Un cas d'usage concret serait la création d'un site e-commerce. En utilisant Rails comme framework backend avec des routes CRUD générées automatiquement, on peut rapidement structurer les fonctionnalités principales de l'e-commerce. Pour gérer les données complexes et volumineuses, PostgreSQL offre des capacités avancées comme la gestion des transactions en cascade, les triggers personnalisés et le support natif pour les types de données géographiques.

Prerequis

• Connaissance de base de Ruby
• Connaissance de l'architecture MVC (Model, View, Controller)
• Connaissance de SQL pour interagir avec les bases de données
• Installation de Ruby en utilisant RVM ou rbenv
• Installation de PostgreSQL
• Installation de Rails via gem install rails

Concepts fondamentaux

1. Modèles et Migrations

Les modèles définissent la structure des données de l'application, tandis que les migrations permettent d'évoluer le schéma de la base de données.

## app/models/task.rb
class Task < ApplicationRecord
end
bash
## Terminal
rails generate model Task title:string description:text completed:boolean
rails db:migrate

2. Contrôleurs et Actions

Les contrôleurs gèrent les requêtes HTTP, interagissent avec le modèle et renvoient des vues.

## app/controllers/tasks_controller.rb
class TasksController < ApplicationController
  def index
    @tasks = Task.all
  end

  def create
    @task = Task.new(task_params)
    if @task.save
      redirect_to tasks_path
    else
      render :new
    end
  end

  private

  def task_params
    params.require(:task).permit(:title, :description, :completed)
  end
end

3. Vues et Templates EJS

Les vues sont des fichiers EJS (Embedded JavaScript) qui affichent les données du modèle.

<!-- app/views/tasks/index.html.erb -->
<h1>Tâches</h1>
<% @tasks.each do |task| %>
  <p><%= task.title %>: <%= task.description %> - <%= task.completed? ? 'Terminée' : 'En cours' %></p>
<% end %>

4. Formulaires

Les formulaires permettent aux utilisateurs de soumettre des données à l'application.

<!-- app/views/tasks/new.html.erb -->
<h1>Nouvelle tâche</h1>
<%= form_with model: @task do |f| %>
  <%= f.label :title %><br>
  <%= f.text_field :title %><br>

  <%= f.label :description %><br>
  <%= f.text_area :description %><br>

  <%= f.submit 'Créer' %>
<% end %>

Mise en pratique : projet fil rouge

Pour ce guide, nous allons créer une application simple de gestion de tâches. L'application aura les fonctionnalités suivantes :

1. Afficher la liste des tâches
2. Ajouter de nouvelles tâches
3. Marquer une tâche comme terminée

Étape 1 : Initialisation du projet

## Terminal
rails new task_manager --database=postgresql
cd task_manager

Étape 2 : Création des modèles et migrations

## Terminal
rails generate model Task title:string description:text completed:boolean
rails db:migrate

Étape 3 : Création des contrôleurs et actions

## app/controllers/tasks_controller.rb
class TasksController < ApplicationController
  def index
    @tasks = Task.all
  end

  def new
    @task = Task.new
  end

  def create
    @task = Task.new(task_params)
    if @task.save
      redirect_to tasks_path
    else
      render :new
    end
  end

  private

  def task_params
    params.require(:task).permit(:title, :description, :completed)
  end
end

Étape 4 : Création des vues et templates EJS

<!-- app/views/tasks/index.html.erb -->
<h1>Tâches</h1>
<% @tasks.each do |task| %>
  <p><%= task.title %>: <%= task.description %> - <%= task.completed? ? 'Terminée' : 'En cours' %></p>
<% end %>

<%= link_to 'Nouvelle tâche', new_task_path %>
html
<!-- app/views/tasks/new.html.erb -->
<h1>Nouvelle tâche</h1>
<%= form_with model: @task do |f| %>
  <%= f.label :title %><br>
  <%= f.text_field :title %><br>

  <%= f.label :description %><br>
  <%= f.text_area :description %><br>

  <%= f.submit 'Créer' %>
<% end %>

Étape 5 : Configuration des routes

## config/routes.rb
Rails.application.routes.draw do
  resources :tasks, only: [:index, :new, :create]
end

Erreurs frequentes et debugging

1. Mauvaise validation des paramètres

   # ❌ Mauvais
   def create
     @task = Task.new(params[:task])
     if @task.save
       redirect_to tasks_path
     else
       render :new
     end
   end
   
   # ✅ Correct
   def create
     @task = Task.new(task_params)
     if @task.save
       redirect_to tasks_path
     else
       render :new
     end
   end
   
   private
   
   def task_params
     params.require(:task).permit(:title, :description, :completed)
   end
   

2. Erreur de migration

   # ❌ Mauvais
   class CreateTasks < ActiveRecord::Migration[6.0]
     def change
       create_table :tasks do |t|
         t.string :title
         t.text :description
         t.boolean :completed
       end
     end
   end
   
   # ✅ Correct
   class CreateTasks < ActiveRecord::Migration[6.0]
     def change
       create_table :tasks do |t|
         t.string :title, null: false
         t.text :description, null: false
         t.boolean :completed, default: false
       end
     end
   end
   

3. Erreur de route

   # ❌ Mauvais
   Rails.application.routes.draw do
     resources :tasks, only: [:index, :new]
   end
   
   # ✅ Correct
   Rails.application.routes.draw do
     resources :tasks, only: [:index, :new, :create]
   end
   

Pour aller plus loin

1. Ajout d'authentification avec Devise

   Pour une application de gestion de tâches, il serait logique d'avoir une authentification des utilisateurs.

2. Intégration d'une API RESTful

   Utiliser Rails pour construire une API backend permettant aux applications mobiles et front-end modernes de s'interfacer avec les données.

3. Tests unitaires et fonctionnels

   Écrire des tests unitaires et fonctionnels pour s'assurer que l'application est robuste et fonctionne correctement sous différents scénarios.

Défi pratique : Ajouter une fonctionnalité de filtrage des tâches (par exemple, afficher uniquement les tâches terminées).

En suivant ce guide complet, vous devriez être capable de créer une application de gestion de tâches robuste et performante en utilisant Rails avec PostgreSQL.