Ruby Gems, Gemfile & Bundler (The Ultimate Guide)

Qu’est-ce qu’un gem Ruby ?

Un gem est un paquet que vous pouvez télécharger &installer. Lorsque vous avez besoin d’une gemme installée, vous ajoutez des fonctionnalités supplémentaires à votre programme Ruby.

Les gemmes vous permettent :

Ajouter une fonctionnalité de connexion à votre application Rails
Facilement travailler avec des services externes (comme les API)
Construire une application web

Ce ne sont que quelques exemples. Chaque gemme a son propre objectif.

Pourquoi utilisons-nous des gemmes ?

C’est la façon dont nous partageons les bibliothèques &ou les outils en Ruby
La structure de fichier &du format d’une gemme permet de comprendre facilement comment elles fonctionnent
Un fichier de spécification (« .spec ») qui accompagne chaque gemme décrit les dépendances (autres gemmes requises) afin que le code ait tout ce dont il a besoin pour fonctionner

Grâce à RubyGems, nous avons un riche écosystème de bibliothèques utiles juste à une gem install distance !

Une liste de gemmes requises pour un projet donné (non gemme) peut être répertoriée sur un fichier spécial appelé « Gemfile » afin qu’elles puissent être automatiquement installées par Bundler. Les deux sont couverts plus loin dans ce guide.

Quels sont les exemples de gems?

Rails, et tous ses composants (ActiveRecord, ActiveSupport, etc.) sont distribués en tant que gemmes Ruby
Pry, la puissante alternative à irb
Nokogiri, un analyseur XML & HTML populaire

La plupart des gemmes sont du code Ruby pur.

Quelques gemmes incluent une extension Ruby C pour améliorer les performances.

Cette extension est construite automatiquement pour vous lorsque vous installez la gemme. Dans certains cas, vous pouvez avoir besoin d’installer manuellement des logiciels supplémentaires qui ne sont pas gérés par RubyGems.

Maintenant :

Apprenons-en plus sur les gemmes en construisant votre propre & en regardant les fichiers qui composent une gemme.

Comment construire une RubyGem

Vous pouvez préparer les fichiers pour une nouvelle gemme en exécutant bundle gem <name>.

Par exemple :

bundle gem awesome_gem

Une gemme est composée de la structure suivante :

├── awesome_gem.gemspec├── bin│ ├── console│ └── setup├── Gemfile├── lib│ ├── awesome_gem│ │ └── version.rb│ └── awesome_gem.rb├── Rakefile├── README.md└── test ├── awesome_gem_test.rb └── test_helper.rb

Ce fichier .gemspec est l’endroit où vous trouverez toutes les informations sur la gemme.

Il comprend :

Nom de la gemme
Résumé de la gemme (courte description)
Nom de l’auteur
Liste de dépendances
Liste des fichiers à inclure dans la gemme
Optionnel : Adresse électronique de l’auteur, URL du projet (page d’accueil), exécutables, extensions c, description longue.

La version de la gemme elle-même est définie comme une constante dans lib/<gem_name>/version.rb.

Voici un exemple de gemspec:

Gem::Specification.new do |spec| spec.name = "awesome_gem" spec.version = AwesomeGem::VERSION spec.authors = spec.summary = "Example gem for article about Ruby gems" spec.files = Dir.grep_v(/.gem$/) spec.require_paths = spec.add_development_dependency "bundler", "~> 1.16" spec.add_development_dependency "rake", "~> 10.0" spec.add_development_dependency "minitest", "~> 5.0"end

Le tableau require_paths est l’endroit où Ruby cherchera vos fichiers gemmes lorsque vous en aurez besoin. Cela vous permet de mettre votre code sous lib/<gem_name>/ & puis de l’exiger avec require "<gem_name>/<file_name>".

Par exemple:

Un fichier nommé lib/awesome_gem/parser.rb serait exigé comme require "awesome_gem/parser" de n’importe où à l’intérieur de la gem.

Vous aurez la plupart de vos exigences dans lib/<gem_name>.rb (le seul fichier à la racine de /lib).

C’est le fichier qui est chargé lorsque vous requirela gemme !

Les lignes add_development_dependency définissent les gems que vous allez utiliser pendant le développement.

Ce sont des gems comme minitest, RSpec, ou pry.

Alors que add_dependency définit les gems que vous utilisez dans le cadre de votre code.

Une fois que vous avez modifié la description du résumé & à partir des valeurs par défaut… vous pourrez charger une session irb avec votre gemme en utilisant le programme bin/console que bundle gem crée pour vous.

Exemple:

$ bin/consoleirb(main):001:0>irb(main):002:0>irb(main):003:0> AwesomeGem=> AwesomeGemirb(main):004:0>irb(main):005:0> AwesomeGem::VERSION=> "0.1.0"

Puis vous pouvez empaqueter la gemme en utilisant gem build <name>.gemspec &la publier sur rubygems.org en utilisant gem push.

Qu’est-ce que Bundler ?

Pendant votre apprentissage des gemmes Ruby, vous pouvez également lire sur Bundler.

Mais qu’est-ce que Bundler exactement ?

Bundler est un outil de gestion des dépendances.

RubyGems ne gérait-il pas déjà cela ?

Et bien, il le fait… mais seulement pour les gemmes elles-mêmes.

Votre application Ruby ordinaire n’est pas construite comme une gemme, donc elle n’obtient pas cette fonctionnalité.

C’est pourquoi Bundler existe !

Comprendre les Gemfiles

Avez-vous vu ces fichiers Gemfile ?

C’est là que vous écrivez quelles gemmes vous voulez utiliser pour votre application Ruby.

Ces gemmes seront chargées pour vous sans avoir à requireles charger.

Un Gemfile ressemble à ceci :

ruby '2.5.0'gem 'rails', '~> 5.2.1'gem 'sqlite3'gem 'puma', '~> 3.11'gem 'bootsnap', '>= 1.1.0', require: false

Bundler (et RubyGems depuis la version 2.0) peut lire ce fichier &installer les versions demandées de ces gemmes.

C’est ce que vous devriez voir en exécutant la commande bundle install:

Using turbolinks-source 5.1.0Using turbolinks 5.1.1Using uglifier 4.1.18Using web-console 3.6.2Bundle complete! 18 Gemfile dependencies, 78 gems now installed.Use `bundle info ` to see where a bundled gem is installed.

Maintenant:

Que sont ces symboles (comme ~>) utilisés lors de la déclaration des versions pour chaque gemme dans votre Gemfile ?

Ils vous permettent de demander une gamme de versions.

Vous pouvez dire des choses comme, « Je veux que la version soit égale ou supérieure à 1.2, mais inférieure à 2.0 ».

Ce qui ressemblerait à ceci:

gem 'puma', '~> 1.2'

Le ~> est un raccourci pour cette plage:

gem 'puma', '>= 1.2', '

In the case of , it means exactly this:

'>= 5.2.1', '

The more specific the version number is the more restricted the version range will be.

Gemfile Options & Gemfile.lock

You have a few options when requiring a gem inside a Gemfile.

For example:

You may want to pull a gem from a different source, like GitHub.

This is helpful when you need to use the latest version of the project, even if it hasn't been released on rubygems.org yet.

Here's an example:

gem "rails", git: "[email protected]:rails/rails.git"

Vous pouvez passer une option branchpour utiliser le code d'une branche qui n'est pas master.

gem "awesome_print", git: "[email protected]:awesome-print/awesome_print.git", branch: "v2"

Une autre option que vous pouvez trouver est require: false.

Que fait-elle ?

Elle indique à Bundler de ne pas requérir automatiquement la gemme pour vous. Cela signifie que vous devrez requirel'intégrer dans votre code lorsque vous en aurez besoin.

Ceci est utilisé pour les gemmes dont la portée est limitée.

Par exemple :

Des gemmes que vous utilisez dans une tâche rake spécifique, mais que vous n'utilisez pas dans vos modèles de contrôleurs Rails &. L'avantage est que vous économisez de la mémoire dans votre code d'application parce que vous ne chargez cette gemme que lorsque vous en avez besoin.

Vous pouvez également regrouper les gemmes par environnement.

Cela signifie que vous pouvez avoir des gemmes qui ne sont installées &chargées que dans le développement (comme capybara & pry).

Enfin, bundler crée un Gemfile.lock.

Quelle est la différence ?

Un Gemfile.lock est auto-généré &il dit exactement quelles versions de chaque gemme ont été installées.

Bundler installera ces versions de sorte que lorsque vous déployez cette application en production, ou que vous partagez votre projet avec d'autres développeurs, tout le monde travaillera avec un ensemble identique de gemmes.

Commandes utiles de Gem & Bundler

Commande	Description
gem list	Liste toutes vos gemmes installées. Accepte un argument pour filtrer les gemmes par nom (exemple : `gem list active`)
gem which <name>	Vous donne le chemin où une gemme est installée.
gem search <name>	Recherche des gemmes à partir des sources configurées (par défaut : rubygems.org). Prend une expression régulière (exemple : `gem search "\Aawesome_"`).
gem env	Affiche des informations sur votre environnement gem (version, chemins, configuration).
gem install <nom> -v <version>	Permet d’installer une version spécifique de gem (exemple : `gem install sinatra -v 2.0.0`).
bundle viz	Génère une visualisation du graphe des dépendances pour votre projet actuel.
bundle show	Affiche des informations sur une gemme particulière installée via bundler. Doit être à l’intérieur d’un dossier avec un Gemfile.
bundle outdated	Affiche une liste de gemmes périmées dans le projet actuel. Peut utiliser l’option `--groups` pour les regrouper.
bundle console	Exécute une session irb avec les gems du Gemfile du projet actuel.

Summary

Vous avez appris à connaître RubyGems, le système de paquets pour Ruby. Vous avez également appris comment une gemme est structurée, ce qu’est un Gemfile, Bundler &la différence entre les Gemfile &les Gemfile.lock.

J’espère que vous avez trouvé cela utile !