Alire, le package manager d'Ada

Dans un précédent journal, il m’a été demandé de présenter Alire sous la forme d’une dépêche. Voilà, j’ai fini par prendre le temps et j’ai choisi la façon de le présenter.
Je vous propose donc une sorte de pas-à-pas plutôt qu’une explication un peu brutale

Le but

Nous allons donc créer des crates Alire (les Rustistes auront reconnu le terme).
J’ai bien dit des car cela va permettre de voir les deux types, lib ou bin que l’on peut créer.

Le projet

Le but n’étant pas d’écrire du code Ada, on va prendre un de mes projets préférés qui n’a, au moment de l’écriture de ces lignes, pas de crate associée.
J’ai nommé le Corporate Bullshit Generator, logiciel ô combien indispensable, source inépuisable d’études en scalabilité (autopromotion).

Ce magnifique projet est l’œuvre de Gautier de Montmollin qui produit aussi des choses beaucoup plus sérieuses comme Zip-Ada, une lib pour gérer les archives zip, Ada PDF Writer ou HAC, un compilateur Ada partiel.
Évidemment, tout est codé en pur Ada.

Bon assez causé, on y va direct car c’est NOTRE PROJEEEEETTTT :)

Sommaire

• C’est parti avec les prérequis
  • Installation d’Alire
  • Premiers pas
  • Récupération du code du CBSG sur SF
• Notre première crate, une bibliothèque
• Création d’un crate d’exemples
  • Edition du fichier TOML
  • On est en dev, on n’a rien publié
  • On teste
• Conclusion

C’est parti avec les prérequis

Installation d’Alire

Je ne vais pas paraphraser totalement la doc mais il vous faut installer un compilateur Ada sur votre distribution, histoire d’avoir les bibliothèques du langage dans votre système.
Ensuite, on télécharge le binaire et on le met dans son PATH pour être tranquille.
Les courageux pourront construire à partir des sources.

Premiers pas

Là, encore, je vais faire plus court que la doc officielle.
On va juste vérifier que notre installation fonctionne bien.

fred@tatooine:~/Dev/Ada$ alr get hello
ⓘ Deploying release hello=1.0.1...
-=O=-        #       #         #         #
ⓘ Deploying release libhello=1.0.0...
############################################################################################################################################################ 100,0%

hello=1.0.1 successfully retrieved.
Dependencies were solved as follows:

   + libhello 1.0.0 (new)

On va ensuite dans le répertoire créé (aujourd’hui, hello_1.0.1_dcc36a2f) et on exécute :

fred@tatooine:~/Dev/Ada$ alr run
Welcome to the toolchain selection assistant

In this assistant you can set up the default toolchain to be used with any crate
that does not specify its own top-level dependency on a version of gnat or
gprbuild.

If you choose "None", Alire will use whatever version is found in the
environment.

ⓘ gnat is currently not configured. (alr will use the version found in the environment.)

Please select the gnat version for use with this configuration
  1. gnat_native=11.2.4
  2. None
  3. gnat_external=2021.0.0 [Detected at /opt/gnat/2021/bin/gnat]
  4. gnat_arm_elf=11.2.4
  5. gnat_avr_elf=11.2.4
  6. gnat_riscv64_elf=11.2.4
  7. gnat_arm_elf=11.2.3
  8. gnat_native=11.2.3
  9. gnat_riscv64_elf=11.2.3
  0. gnat_arm_elf=11.2.2
  a. (See more choices...)
Enter your choice index (first is default):
> 3
ⓘ Selected tool version gnat_external=2021.0.0

ⓘ Choices for the following tool are narrowed down to releases compatible with just selected gnat_external=2021.0.0

ⓘ gprbuild is currently not configured. (alr will use the version found in the environment.)

Please select the gprbuild version for use with this configuration
  1. gprbuild=2021.0.0 [Detected at /opt/gnat/2021/bin/gprbuild]
  2. None
Enter your choice index (first is default):
> 1
ⓘ Selected tool version gprbuild=2021.0.0
Setup
   [mkdir]        object directory for project Libhello
   [mkdir]        library directory for project Libhello
   [mkdir]        object directory for project Hello
Compile
   [Ada]          hello.adb
   [Ada]          libhello.adb
Build Libraries
   [gprlib]       hello.lexch
   [archive]      libhello.a
   [index]        libhello.a
Bind
   [gprbind]      hello.bexch
   [Ada]          hello.ali
Link
   [link]         hello.adb
Hello, world!

Mais alors, il s’est passé quoi ?
Normalement, si c’est votre première installation, comme ci-dessus, Alire va vous demander de choisir votre toolchain en fonction de ce qui se trouve dans votre système.
Personnellement, j’ai, entre autres, la version 2021 du compilateur fourni par Adacore dans /opt/gnat.
Ensuite, le binaire n’étant pas encore créé, on passe par un build puis une exécution.

Qu’on se rassure, le processus de choix de la toolchain ne se fait qu’une fois, mais il est possible de changer en cours de route via les commandes alr toolchain.

De manière générale, à l’instar de beaucoup d’autres outils, on peut utiliser l’aide en ligne via alr help comme alr help toolchain.

Maintenant que l’on voit que cela fonctionne, on passe aux choses sérieuses.

Récupération du code du CBSG sur SF

Le code du Corporate Bullshit Generator (CBSG pour les intimes) est disponible sur Sourceforge et possède un miroir sur Github

On récupère soit via

svn checkout https://svn.code.sf.net/p/cbsg/code/ cbsg-code

soit via

git clone https://github.com/zertovitch/cbsg.git cbsg-code

L’un ou l’autre ne pose aucun problème, cela ne servira qu’à piocher dans le code source.

Préparons maintenant notre première crate, une lib.

Notre première crate, une bibliothèque

On commence par créer un patron de crate

fred@tatooine:~/Dev/Ada$ alr init --lib cbsg

Cela donne la hiérarchie suivante:

cbsg
├── alire.toml
├── cbsg.gpr
├── config
│   ├── cbsg_config.ads
│   ├── cbsg_config.gpr
│   └── cbsg_config.h
└── src
    └── cbsg.ads

Quand on analyse le code du Corporate Bullshit Generator, on voit qu’un package fournit la fonctionnalité que l’on veut exposer.
En effet, corporate_bullshit est le package générique donnant les fonctions retournant les phrases tant attendues.

generic
   Paragraph_Mark     : String;
   Paragraph_End_Mark : String;
   Dialog_Mark        : String;
package Corporate_Bullshit is

   function Sentence return String;
   function Workshop return String;
   function Short_Workshop return String;
   function Short_Meeting return String;
   function Financial_Report return String;

end Corporate_Bullshit;

On incorporera donc le fichier de spécification corporate_bullshit.ads ainsi que le corps du package, corporate_bullshit.adb.

Il manque encore une chose. En regardant le début du fichier corporate_bullshit.adb, on voit deux packages en inclusion, Ada.Characters.Handling et Delirium.

with Ada.Characters.Handling;           use Ada.Characters.Handling;
with Delirium;                          use Delirium;

Ada.Characters.Handling est un package standard Ada permettant la transformation majuscule/minuscule, les tests d’appartenance d’un caractère à une classe (alphanumérique, numérique…) entre autres choses.

Delirium est un package du CBSG. D’après les commentaires, il permet de gérer la grammaire des phrases générées. Ce n’est pas le plus clair des codes que j’ai vu mais ça fonctionne et comme on ne s’en sert pas directement…

Par contre, cela veut dire qu’il doit faire partie de notre lib.

On copie donc les fichiers ad[sb] de delirium et corporate_bullshit.
Finalement, le fichier généré cbsg.ads ne nous servant pas, on le retire.
Au final, on obtient cela :

cbsg
├── alire.toml
├── cbsg.gpr
├── config
│   ├── cbsg_config.ads
│   ├── cbsg_config.gpr
│   └── cbsg_config.h
└── src
    ├── corporate_bullshit.adb
    ├── corporate_bullshit.ads
    ├── delirium.adb
    └── delirium.ads

On vérifie que tout se passe bien avec un petit alr build dans le répertoire

Setup
   [mkdir]        object directory for project Cbsg
   [mkdir]        library directory for project Cbsg
Compile
   [Ada]          delirium.adb
   [Ada]          corporate_bullshit.adb
Build Libraries
   [gprlib]       Cbsg.lexch
   [archive]      libCbsg.a
   [index]        libCbsg.a

Pour tester tout ça, on va passer à la deuxième partie, la crate d’exemples.

Création d’un crate d’exemples

Maintenant que notre bibliothèque est prête, nous allons créer une crate avec un exemple simple.
Cette fois-ci, on utilisera la commande dans un répertoire au même niveau que le répertoire cbsg. Cela n’a rien d’obligatoire au final mais là, ce sera plus facile mais stop au suspense, on embraye.

fred@tatooine:~/Dev/Ada$ alr init --bin cbsg_examples

Cela donne la hiérarchie suivante:

cbsg_examples
├── alire
│   └── alire.lock
├── alire.toml
├── cbsg_examples.gpr
├── config
│   └── cbsg_examples_config.gpr
└── src
    └── cbsg_examples.adb

Pour exemple, nous prendrons le plus simple qui soit dans le code du CBSG, produce_corporate_bullshit.adb.

On copie donc ce fichier dans le répertoire src.
Le fichier cbsg_examples.adb ne nous sert pas, on le retire… Sauf que le projet s’attend à ce que l’exécutable de notre crate soit cbsg_examples.

Cela étant déclaré dans le fichier cbsg_examples.gpr, on modifie cela.

Ce fichier est un fichier au format GPRBuild.
GPRBuild, c’est un outil fourni par Adacore qui est un peu le make sur-vitaminé de GNAT, ce dernier disposant déjà de gnatmake.
La syntaxe se veut très Ada, mais il n’est pas compliqué dans notre cas de modifier celui généré pour changer l’exécutable.

Ainsi, il suffit de trouver la ligne

for Main use ("cbsg_examples.adb");

et de la transformer en

for Main use ("produce_corporate_bullshit.adb");

Au final, on obtient l’arbre suivant :

cbsg_examples/
├── alire
│   ├── alire.lock
├── alire.toml
├── cbsg_examples.gpr
├── config
│   ├── cbsg_examples_config.ads
│   ├── cbsg_examples_config.gpr
│   └── cbsg_examples_config.h
└── src
    └── produce_corporate_bullshit.adb

So far so good… sauf que l’on n’a précisé nulle part la dépendance à cbsg !!!

Pour cela, on utilisera la commande

fred@tatoiine:~/Dev/Ada/cbsg_examples$ alr with cbsg

Dans un cas normal, cela suffirait si la crate cbsg était déjà publiée mais ce n’est pas notre cas.

Edition du fichier TOML

Le fichier généré par Alire est au format TOML (pour ceux qui n’auraient pas vu) et contient maintenant ceci:

name = "cbsg_examples"
description = "Corporate bullshit generator examples"
version = "0.0.1"

authors = ["Gautier de Montmollin"]
maintainers = ["Frédéric Praca <xxxxxxxxxxxxx>"]
maintainers-logins = ["FredPraca"]

executables = ["cbsg_examples"]
[[depends-on]]  # Added by alr
cbsg = "*"  # Added by alr

C’est bien mais pas complétement, on voit une première erreur.
Les exécutables produits sont faux. On ne génère plus cet exécutable, cbsg_examples, mais produce_corporate_bullshit… Simple à modifier.

L’autre chose, c’est que l’on voit bien la dépendance vers la crate cbsg avec n’importe quelle version (le "*"). Pour plus d’informations, il faut aller voir la doc d’Alire sur les informations du TOML (ça fait du semver pour la sélection des versions de crate).

On est en dev, on n’a rien publié

Dans notre cas, comme la crate cbsg n’a pas été publiée, on fait un override, on va donc ajouter un petit morceau à notre TOML pour préciser où trouver notre dépendance.

[[pins]]
cbsg = { path = "../cbsg" }  # Overridden by local version

Et voilà, on a ajouté une épingle sur la version à utiliser, il s’agira de celle se trouvant dans le répertoire cbsg.

Le fichier complet devient donc :

name = "cbsg_examples"
description = "Corporate bullshit generator examples"
version = "0.0.1"

authors = ["Gautier de Montmollin"]
maintainers = ["Frédéric Praca <xxxxxxxxx>"]
maintainers-logins = ["FredPraca"]

executables = ["produce_corporate_bullshit"]
[[depends-on]]  # Added by alr
cbsg = "*"  # Added by alr
[[pins]]
cbsg = { path = "../cbsg" }  # Overridden by the latest sources

On teste

fred@tatooine:~/Dev/Ada/cbsg_examples$ alr run

Si cela n’a pas déjà été contsruit, on a l’étape de construction et le lancement de l’exécutable.

Compile
   [Ada]          produce_corporate_bullshit.adb
   [Ada]          delirium.adb
   [Ada]          corporate_bullshit.adb
Build Libraries
   [gprlib]       Cbsg.lexch
   [archive]      libCbsg.a
   [index]        libCbsg.a
Bind
   [gprbind]      produce_corporate_bullshit.bexch
   [Ada]          produce_corporate_bullshit.ali
Link
   [link]         produce_corporate_bullshit.adb
New corporate bullshit is in bullshit.html.  Enjoy.  Use switch -h for help about options.

Le programme écrit par défaut un fichier HTML que vous pouvez ouvrir avec votre navigateur préféré pour obtenir une belle série de bullshits :)

Si on ne veut pas de fichier HTML:

fred@tatooine:~/Dev/Ada/cbsg_examples$ bin/produce_corporate_bullshit --one
Roles and responsibilities consistently engage goals-based and cloud-based timelines.

Conclusion

Le but de cet article était de présenter Alire de façon un peu plus ludique que la documentation officielle en fournissant un premier exemple. Cela a permis de montrer toutefois le pinning de version que l’on peut considérer comme une utilisation avancée.

Alire est un outil en cours de développement et les crates ne sont pas encore nombreuses, on n’en compte que 243 à ce jour, mais tout cela est d’ores et déjà utilisable.
Alire contient des crates diverses et variées qui peuvent couvrir le développement standard tout comme le développement embarqué bare metal ou le développement Spark.

D’ailleurs, si cela n’a été qu’effleurer, Alire permet la gestion des toolchains au sein des crates, permettant ainsi de préciser une dépendance à un compilateur particulier. Ainsi, certaines crates tirent une dépendance vers le compilateur croisé ARM

Si Alire, tout comme pip, cargo ou npm rentre en collision avec le gestionnaire de paquets de votre distribution, cela reste toutefois un bon moyen de développer rapidement du code Ada.

Cherry on the cake, si vous avez GnatStudio d’installé, la commande alr edit ouvrira le projet dans celui-ci :)

Amusez-vous bien !

Aller plus loin

• Alire (35 clics)
• Releases d'Alire (18 clics)
• Corporate bullshit Generator Live (34 clics)
• La liste des crates (20 clics)