Debuter avec Rails

Débuter avec Rails

Pourquoi Rails ?

Rails est un framework web Ruby qui vise à simplifier le développement d'applications web en fournissant des outils puissants tout en restant accessible pour les débutants. Il suit la philosophie du DRY (Don't Repeat Yourself), ce qui signifie qu'il encourage à réutiliser autant que possible le code afin de minimiser les erreurs et d'accélérer le développement.

Un cas concret en 2-3 phrases : Imaginez que vous soyez un développeur web indépendant. Vous avez besoin de créer une application pour gérer vos tâches quotidiennes, comme planifier des rappels, marquer des tâches comme faites, et partager ces tâches avec d'autres utilisateurs. Avec Ruby on Rails, vous pouvez construire cette application en un temps record tout en respectant les meilleures pratiques de développement web.

Prerequis

• Connaissance de base du langage de programmation Ruby
• Installation de Ruby (version 3.x recommandée)
• Installation d'un éditeur de texte ou d'un IDE comme Visual Studio Code, Sublime Text, ou Atom
• Installation de Git pour le contrôle de version
• Installation de PostgreSQL (ou MySQL) pour la base de données

Concepts fondamentaux

1. Modèle-Vue-Contrôleur (MVC)

Le MVC est une structure de conception qui sépare l'application en trois composants principaux :

• Modèle : Contient la logique métier et les données de l'application.
• Vue : Gère l'affichage des données au utilisateur. Dans Rails, c'est généralement un fichier HTML avec des balises ERB (Embedded Ruby).
• Contrôleur : Gère les requêtes HTTP, effectue des opérations sur le modèle et retourne la vue à afficher.

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

  def show
    @task = Task.find(params[:id])
  end

  def new
    @task = Task.new
  end

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

  private

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

2. Générateurs

Les générateurs sont des commandes qui facilitent la création de code répétitif dans Rails. Par exemple, le générateur rails generate controller Tasks crée les fichiers pour un nouveau contrôleur.

rails generate controller Tasks index show new create

3. Routing

Le routing est responsable d'associer les URL aux actions des contrôleurs. Il est défini dans le fichier config/routes.rb.

## config/routes.rb
Rails.application.routes.draw do
  resources :tasks
end

4. Base de données et ORM (Object-Relational Mapping)

Rails utilise Active Record comme ORM, qui facilite l'interaction avec la base de données.

## app/models/task.rb
class Task < ApplicationRecord
  validates :title, presence: true
end

Mise en pratique : projet fil rouge

Nous allons construire un gestionnaire de tâches simple avec Rails. Nous aurons besoin des fonctionnalités suivantes :

1. Afficher la liste des tâches
2. Ajouter une nouvelle tâche
3. Voir les détails d'une tâche

Étape 1 : Initialisation du projet

rails new task_manager
cd task_manager

Étape 2 : Création de la base de données et des modèles

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

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

rails generate controller Tasks index show new create edit update destroy

Étape 4 : Configuration du routing

Modifier config/routes.rb :

Rails.application.routes.draw do
  resources :tasks
end

Étape 5 : Création de la base de données et des modèles

Créer un modèle pour les tâches :

## app/models/task.rb
class Task < ApplicationRecord
  validates :title, presence: true
end

Étape 6 : Création des vues

Modifier les fichiers ERB dans app/views/tasks :

• index.html.erb
• show.html.erb
• new.html.erb
• edit.html.erb

Étape 7 : Ajout des contrôleurs

Modifier les fichiers Ruby dans app/controllers/tasks_controller.rb :

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

  def show
    @task = Task.find(params[:id])
  end

  def new
    @task = Task.new
  end

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

  def edit
    @task = Task.find(params[:id])
  end

  def update
    @task = Task.find(params[:id])
    if @task.update(task_params)
      redirect_to @task
    else
      render :edit
    end
  end

  def destroy
    @task = Task.find(params[:id])
    @task.destroy
    redirect_to tasks_path
  end

  private

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

Erreurs frequentes et debugging

1. undefined method 'tasks_path'

## config/routes.rb
Rails.application.routes.draw do
  resources :tasks
end

Corrigé :

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

2. ActiveRecord::UnknownAttributeError

## app/models/task.rb
class Task < ApplicationRecord
  validates :title, presence: true
end

Corrigé :

## app/controllers/tasks_controller.rb
def task_params
  params.require(:task).permit(:title, :description, :completed)
end

3. No route matches [GET] "/tasks/new"

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

Corrigé :

## config/routes.rb
Rails.application.routes.draw do
  resources :tasks
end

Pour aller plus loin

1. Authentification et autorisation

• Utiliser Devise pour l'authentification des utilisateurs.
• Configurer les permissions avec Pundit.

Liens : Devise | Pundit

2. Tests unitaires et d'intégration

• Écrire des tests pour vos contrôleurs et modèles.
• Utiliser RSpec pour les tests.

Liens : RSpec

3. API RESTful

• Créer une API RESTful pour un autre service à consommer.
• Utiliser ActiveModel::Serializer pour la sérialisation des données.

Liens : ActiveModel::Serializer

Défi pratique : Ajouter l'authentification pour que seuls les utilisateurs connectés puissent créer, modifier et supprimer des tâches.