Introduction à Ruby on Rails et Configuration de l'Environnement

Bienvenue dans ce cours dédié à Ruby on Rails, le framework qui a révolutionné le développement web ! Que vous soyez un développeur débutant ou expérimenté, Rails offre une approche puissante et efficace pour bâtir des applications web robustes et évolutives. Cette leçon introductive vous plongera dans l'univers de Rails et vous guidera pas à pas pour configurer votre environnement de développement.

Prérequis

Avant de plonger dans le vif du sujet, il est utile d'avoir une compréhension de base des concepts suivants :

Ruby : Rails est écrit en Ruby. Une connaissance des bases du langage (variables, types de données, méthodes, classes, modules) est fortement recommandée.
Ligne de commande / Terminal : Vous interagirez beaucoup avec votre système via le terminal. Des notions de navigation dans les répertoires, d'exécution de commandes sont essentielles.
Concepts Web de base : HTTP, requêtes/réponses, HTML, CSS, JavaScript.

Comprendre Ruby on Rails

Ruby on Rails, souvent appelé simplement "Rails", est un framework de développement d'applications web côté serveur (backend) écrit en langage Ruby. Il fournit une structure, des outils et des conventions pour vous aider à écrire du code rapidement et de manière maintenable.

La Philosophie de Rails

Rails repose sur plusieurs principes fondamentaux qui le distinguent et en font un outil de choix pour la productivité :

Convention over Configuration (CoC) : Plutôt que de devoir configurer manuellement chaque aspect de votre application, Rails propose des conventions par défaut. En les suivant, vous écrivez moins de code et gagnez du temps. Si vous avez besoin de quelque chose de spécifique, vous pouvez toujours reconfigurer.
Don't Repeat Yourself (DRY) : Ce principe encourage la réutilisation du code et la réduction de la duplication. Chaque pièce d'information (ou logique) doit avoir une source unique et faisant autorité.
Rapid Development : Grâce au CoC, à la multitude de générateurs et à une architecture bien pensée, Rails permet de développer des fonctionnalités à une vitesse impressionnante.
Full-stack Framework : Rails gère à la fois le backend (base de données, logique métier, API) et le frontend (rendu des vues HTML, gestion des assets JavaScript/CSS).

L'Architecture MVC (Modèle-Vue-Contrôleur)

Rails adhère fermement au modèle architectural Modèle-Vue-Contrôleur (MVC), qui sépare les préoccupations d'une application web en trois composants interconnectés :

Modèle (Model) :
- Représente les données et la logique métier de votre application.
- Il interagit directement avec la base de données (lecture, écriture, validation).
- Dans Rails, les modèles sont généralement des classes qui héritent d'Active Record, l'ORM (Object-Relational Mapping) de Rails.
Vue (View) :
- Responsable de la présentation des données à l'utilisateur.
- Généralement du code HTML, CSS et JavaScript, avec des balises Ruby incrustées (ERB ou Haml/Slim).
- Elle ne contient aucune logique métier, se contentant d'afficher ce que le contrôleur lui transmet.
Contrôleur (Controller) :
- Agit comme un intermédiaire entre le Modèle et la Vue.
- Il reçoit les requêtes des utilisateurs (via le navigateur), interagit avec le Modèle pour récupérer ou manipuler les données, puis prépare les données pour la Vue et lui demande de rendre la page appropriée.
- Chaque action dans un contrôleur correspond généralement à une URL spécifique.

Flux typique d'une requête dans Rails (MVC) :

L'utilisateur envoie une requête via son navigateur (ex: GET /articles/1).
Rails identifie le contrôleur et l'action correspondants à cette requête (ex: ArticlesController#show).
Le contrôleur interagit avec le Modèle (Article) pour récupérer l'article avec l'ID 1.
Le Modèle interagit avec la base de données.
Le contrôleur reçoit les données de l'article et les passe à la Vue (ex: app/views/articles/show.html.erb).
La Vue rend la page HTML en utilisant les données fournies.
Le contrôleur envoie la page HTML générée au navigateur de l'utilisateur.

L'Écosystème Rails

Rails est bien plus qu'un simple framework ; c'est un écosystème riche et mature :

Gems : RubyGems est le gestionnaire de paquets de Ruby. Des milliers de "gems" (bibliothèques) sont disponibles pour ajouter des fonctionnalités à votre application (authentification, paiements, upload de fichiers, etc.).
Bundler : Un outil indispensable pour gérer les dépendances (gems) de votre projet. Il assure que chaque développeur utilise les mêmes versions de gems, évitant les problèmes de compatibilité.
Active Record : L'ORM par défaut de Rails, il rend l'interaction avec la base de données simple et intuitive en mappant les objets Ruby aux tables de la base de données.
Action Pack : Regroupe les composants Action Controller (gestion des requêtes) et Action View (rendu des vues).
Rails Guides & Communauté : Une documentation exhaustive et une communauté très active sont des atouts majeurs pour l'apprentissage et la résolution de problèmes.

Configuration de l'Environnement de Développement

Pour commencer à développer avec Rails, vous devez d'abord configurer votre environnement. Suivez ces étapes attentivement.

1. Installation de Ruby

Il est fortement recommandé d'utiliser un gestionnaire de versions de Ruby comme rbenv ou RVM. Ces outils vous permettent d'installer plusieurs versions de Ruby sur votre machine et de basculer facilement entre elles, ce qui est crucial si vous travaillez sur différents projets. Pour cette leçon, nous allons utiliser rbenv qui est généralement plus léger et moins intrusif.

Installez rbenv et ruby-build (un plugin pour rbenv qui facilite l'installation des versions de Ruby).

Sur macOS (avec Homebrew) :
```
brew install rbenv ruby-build
```

Sur Linux (Ubuntu/Debian) :

sudo apt update
sudo apt install git curl libssl-dev libreadline-dev zlib1g-dev autoconf bison build-essential libyaml-dev libffi-dev libgdbm-dev libncurses5-dev
git clone https://github.com/rbenv/rbenv.git ~/.rbenv
git clone https://github.com/rbenv/ruby-build.git ~/.rbenv/plugins/ruby-build

Configurez votre shell pour qu'il charge rbenv. Ajoutez les lignes suivantes à la fin de votre fichier ~/.bashrc, ~/.zshrc ou ~/.profile (en fonction de votre shell) :
```
echo 'eval "$(~/.rbenv/bin/rbenv init - zsh)"' >> ~/.zshrc # ou ~/.bashrc
source ~/.zshrc # ou ~/.bashrc
```
Redémarrez votre terminal ou exécutez source sur le fichier modifié.
Installez une version de Ruby. Vérifiez la dernière version stable recommandée pour Rails sur le site officiel de Rails. Par exemple, pour Ruby 3.2.2 :
```
rbenv install 3.2.2
```
Cela peut prendre quelques minutes.
Définissez cette version comme version globale par défaut :
```
rbenv global 3.2.2
```
Vérifiez votre installation de Ruby :
```
ruby -v
```
Vous devriez voir ruby 3.2.2p... (ou la version que vous avez installée).

2. Installation de Rails

Une fois Ruby installé, vous pouvez installer Rails. Rails est une "gem" Ruby.

gem install rails

Cette commande installera la dernière version stable de Rails ainsi que toutes ses dépendances. Pour installer une version spécifique (recommandé pour la production ou le suivi d'un tutoriel), par exemple Rails 7.1.3 :

gem install rails -v 7.1.3

Vérifiez que Rails est bien installé :

rails -v

Vous devriez voir Rails 7.1.3 (ou la version installée).

3. Configuration de la Base de Données

Rails peut fonctionner avec différentes bases de données. Pour cette leçon, nous recommandons PostgreSQL, car c'est un choix courant en production et très performant. SQLite est aussi une option par défaut, plus simple pour démarrer, mais moins adaptée à des applications complexes.

Sur macOS (avec Homebrew) :

brew install postgresql
# Démarrer PostgreSQL :
brew services start postgresql

Sur Linux (Ubuntu/Debian) :

sudo apt update
sudo apt install postgresql postgresql-contrib libpq-dev
# Le service PostgreSQL démarre généralement automatiquement.
# Pour vérifier l'état :
sudo systemctl status postgresql

Pour d'autres systèmes ou pour Windows, vous devrez suivre les instructions spécifiques à votre OS. Sur Windows, l'utilisation de WSL (Windows Subsystem for Linux) est fortement recommandée pour une expérience de développement Rails optimale.

4. Installation de Node.js et Yarn

Rails moderne utilise Node.js et Yarn (ou npm) pour gérer les dépendances JavaScript et le pipeline d'assets (compilation de CSS/JS).

Sur macOS (avec Homebrew) :
```
brew install node yarn
```

Sur Linux (Ubuntu/Debian) :

sudo apt install nodejs npm
sudo npm install -g yarn # installe Yarn globalement via npm

Vérifiez les installations :

node -v
yarn -v

5. Installation de Git

Git est le système de contrôle de version le plus utilisé et est essentiel pour tout projet de développement. Il est souvent préinstallé sur macOS et de nombreuses distributions Linux.

Vérifiez si Git est déjà installé :

git --version

Si non, installez-le :

Sur macOS : Xcode Command Line Tools inclut Git. xcode-select --install
Sur Linux (Ubuntu/Debian) : sudo apt install git
Sur Windows : Téléchargez l'installeur depuis git-scm.com.

Création de Votre Première Application Rails

Maintenant que votre environnement est configuré, nous pouvons générer notre première application Rails.

Générer l'Application

Naviguez dans votre terminal jusqu'au dossier où vous souhaitez créer votre projet (ex: ~/Sites ou ~/Documents/Projects).

cd ~/Documents/Projects # Naviguez vers votre répertoire de projets
rails new mon_super_blog --database=postgresql

rails new : La commande pour générer une nouvelle application Rails.
mon_super_blog : Le nom de votre application. Un nouveau dossier sera créé avec ce nom.
--database=postgresql : Indique à Rails d'utiliser PostgreSQL comme base de données principale au lieu de SQLite (qui est la valeur par défaut).

Cette commande va :

Créer une nouvelle arborescence de dossiers pour votre application.
Installer les gems nécessaires (gérées par Bundler).
Initialiser un dépôt Git.

Une fois la génération terminée, accédez au répertoire de votre nouvelle application :

cd mon_super_blog

Ensuite, vous devez créer les bases de données (une pour le développement et une pour les tests) :

rails db:create

Cette commande utilisera les informations de connexion PostgreSQL définies dans le fichier config/database.yml de votre projet. Si vous rencontrez des problèmes, assurez-vous que votre serveur PostgreSQL est en cours d'exécution et que les identifiants sont corrects (par défaut, Rails essaie de se connecter en tant que votre utilisateur système).

Explication de la Structure du Projet

Une application Rails a une structure de répertoire bien définie. Voici les plus importants :

app/ : C'est le cœur de votre application. Il contient :
- app/models/ : Vos classes Modèle.
- app/views/ : Vos fichiers de Vue.
- app/controllers/ : Vos classes Contrôleur.
- app/helpers/ : Modules pour la logique d'aide dans les vues.
- app/assets/ : Fichiers CSS, JavaScript et images pour le frontend.
bin/ : Scripts utilitaires comme rails lui-même.
config/ : Contient les fichiers de configuration de votre application (routes, base de données, environnements, etc.). config/routes.rb est particulièrement important pour définir les chemins URL de votre application. config/database.yml pour la configuration de la base de données.
db/ : Contient les migrations de base de données (instructions pour modifier le schéma de votre base de données) et le schéma actuel.
lib/ : Utilitaires personnalisés.
public/ : Contient les fichiers statiques accessibles publiquement (images, fichiers HTML de base).
test/ : Contient les tests pour votre application.
vendor/ : Peut contenir des ressources tierces non gérées par Bundler.
Gemfile : Liste toutes les dépendances (gems) de votre application. Bundler utilise ce fichier.
Gemfile.lock : Fichier généré par Bundler qui enregistre les versions exactes des gems utilisées.

Cette structure respecte les conventions de Rails et aide à maintenir le code organisé et prévisible.

Démarrage de l'Application

Pour voir votre application en action, démarrez le serveur de développement local de Rails :

rails server

Ou sa version courte :

rails s

Vous devriez voir une sortie similaire à :

=> Booting Puma
=> Rails 7.1.3 application starting in development
=> Run `bin/rails server --help` for more startup options
Puma starting in single mode...
* Version 6.0.2 (ruby 3.2.2-p53), codename: KIRK GAINS
* Min threads: 5, max threads: 5
* Environment: development
* Listening on http://127.0.0.1:3000
* Listening on http://[::1]:3000
Use Ctrl-C to stop

Votre application est maintenant accessible via votre navigateur web à l'adresse suivante :

http://localhost:3000

Vous devriez voir la page d'accueil par défaut de Rails, confirmant que votre installation est réussie et que l'application est en cours d'exécution.

Conclusion

Félicitations ! Vous avez fait vos premiers pas dans le monde de Ruby on Rails. Dans cette leçon, vous avez appris ce qu'est Rails, sa philosophie et son architecture MVC. Plus important encore, vous avez configuré un environnement de développement complet et lancé votre première application Rails.

Vous avez maintenant les bases solides pour explorer davantage :

Générer des ressources (modèles, contrôleurs, vues)
Définir des routes
Interagir avec la base de données
Ajouter des fonctionnalités à votre application

Le chemin vers la maîtrise de Rails est passionnant. N'hésitez pas à expérimenter, à lire la documentation officielle et à explorer le code généré pour comprendre comment tout s'assemble.