Que sont les gems et Bundler ?

Question

Accepted Answer

**Gems** sont les paquets Ruby (bibliothèques) distribués via RubyGems. **Bundler** gère les dépendances en gems d'un projet — en installant les bonnes versions et en garantissant des environnements **cohérents et reproductibles** sur plusieurs machines via un fichier de verrouillage. Ensemble, ils forment le système de gestion des dépendances des projets Ruby.

## Gems — paquets Ruby

```bash
gem install rails          # install a gem globally
gem list                   # list installed gems
# gems come from rubygems.org — the central package registry (Rails, RSpec, etc.)
```

Une gem est une bibliothèque Ruby empaquetée (code + métadonnées). RubyGems est le gestionnaire de paquets et rubygems.org le registre — l'équivalent Ruby de npm/pip.

## Bundler — gestion des dépendances du projet

```ruby
# Gemfile — declares your project's gem dependencies
source "https://rubygems.org"

gem "rails", "~> 7.0"        # version constraint (~> allows compatible updates)
gem "pg"                     # PostgreSQL adapter
gem "rspec", group: :test    # only in the test environment
```

```bash
bundle install               # install all gems from the Gemfile (creates Gemfile.lock)
bundle update                # update gems to newer allowed versions
bundle exec rspec            # run a command with the project's exact gem versions
```

Le **`Gemfile`** déclare les dépendances de votre projet avec des contraintes de version. `bundle install` les installe et génère le **`Gemfile.lock`**.

## Le fichier de verrouillage — installations reproductibles

```text
Gemfile      → declares dependencies with constraints (e.g. rails ~> 7.0)
Gemfile.lock → records the EXACT versions of every gem (and sub-dependency) installed
→ COMMIT Gemfile.lock → everyone (team, CI, production) gets the IDENTICAL versions.
  Prevents "works on my machine" bugs from version differences.
```

Le **`Gemfile.lock`** épingle les versions exactes de chaque gem (y compris les dépendances transitives), donc en le validant, vous garantissez que tous les développeurs, CI et la production installent l'*arborescence de dépendances identique* — des environnements reproductibles et cohérents. Validez-le toujours.

## bundle exec — utiliser les versions du projet

```bash
bundle exec rspec    # runs rspec using the EXACT versions in Gemfile.lock
# (vs `rspec` which might use a different globally-installed version)
```

## Pourquoi c'est important

Les gems et Bundler sont fondamentaux au développement Ruby — c'est ainsi que pratiquement tous les projets Ruby gèrent les dépendances, donc les comprendre est essentiel. **Gems** (paquets Ruby de rubygems.org) fournissent les bibliothèques et frameworks (Rails, RSpec, etc.) sur lesquels les applications réelles dépendent, et **Bundler** est l'outil standard pour les gérer dans un projet.

La valeur clé que Bundler apporte — et le concept le plus important à comprendre — est **des environnements reproductibles et cohérents** : le **`Gemfile`** déclare les dépendances avec des contraintes de version, et le **`Gemfile.lock`** épingle les *versions exactes* de chaque gem (y compris les dépendances transitives) qui ont été installées.

Valider `Gemfile.lock` garantit que tout le monde — toute l'équipe, CI et la production — installe l'arborescence de dépendances identique, prévenant les bugs du type « ça marche sur ma machine » qui résultent des différences de version.

Cette reproductibilité est critique pour un développement et un déploiement fiables et collaboratifs.

Comprendre les gems (les paquets Ruby), le Gemfile (déclarer les dépendances), `bundle install`, le **fichier de verrouillage et pourquoi le valider** (installations reproductibles — le bénéfice central), et `bundle exec` (exécuter des commandes avec les versions exactes du projet) est une connaissance importante et quotidienne pour tout projet Ruby.

Comme la gestion des dépendances est fondamentale aux applications réelles, et puisque la reproductibilité basée sur le fichier de verrouillage de Bundler est la façon dont les équipes Ruby garantissent des environnements cohérents entre développement, CI et production, maîtriser les gems et Bundler — analogue à npm/package-lock.json en Node — est une connaissance essentielle et fréquemment appliquée pour le développement Ruby professionnel.