Hall – Un gestionnaire de projet pour le langage de programmation Guile
Dans cet article, je vais te présenter Hall, un outil dont le but est de t'assister dans le développement et la distribution de programmes Guile. Je ne couvrirai pas toutes les fonctionnalités de Hall. Juste de quoi te donner envie d'essayer. ;–)
Tu verras comment créer un projet Guile à partir de zéro, comment construire le projet, comment le tester, enfin, comment le distribuer !
Les langages de programmation modernes sont bien souvent accompagnés de leur propre gestionnaire de paquets pour faciliter le partage de code entre développeurs.
Parfois, ces outils ne se limitent pas à la gestion pure et simple de paquets et intègrent de quoi construire des exécutables, dérouler des suites de tests, déployer le logiciel, et plus si affinité :
- Ruby a RubyGems.
- Python a Pip.
- Javascript a Node.
- Kotlin a Gradle.
- Go a Go.
- Rust a Cargo.
En version 2, Guile disposait de GuildHall, mené par Ian Price. Un outil capable d'installer, mettre à jour et désinstaller des logiciels codés en Guile. Le projet disposait déjà d'une bonne base de paquets.
Mais ça, c'était avant. Maintenant, il y a Hall, un projet mené par Alex Sassmannshausen depuis 2018 qui supporte la version 3 du langage et tire profit des fonctionnalités de Guix (et ça c'est cool) !
D'après le README du dépôt de Hall, voici ce dont il est capable :
- Gérer une hiérarchie de projet Guile à partir d'un unique fichier de spécifications de projet.
- Supporter de manière transparente le système de construction GNU pour une portabilité maximale.
- Tirer parti d'un couplage étroit avec Guix pour la fiabilité et la confiance.
- Être bénéfique
Ne sachant pas utiliser le système de construction GNU, Hall me retire une sacrée épine du pied.
Avec Hall, tout tourne autour du fichier hall.scm qui sert à spécifier un projet. Grâce à cette spécification, Hall va être en mesure de générer l'infrastructure pour construire, tester et distribuer le projet en bon et due forme.
A ce jour, Hall est en version 0.3.1. Pour l'installer, j'utilise Guix (comme pour tout ce qui concerne Guile).
$ guix install guile-hall
Maintenant, place à la démonstration.
Initialiser un nouveau projet Guile avec Hall :
$ hall init dummy --author="Red Nose Hacker" --license="gpl3+" --prefix="guile" --execute
Voila, un nouveau projet dénommé dummy est initialisé ! Hall a créé un répertoire guile-dummy (parce que j'ai demandé à ce qu'il soit préfixé) et y a construit une arborescence de pro ! Pas mal de choses ont été faite automatiquement (même la doc est préparée), je te laisse fouiller.
$ tree -a
.
├── COPYING
├── doc
│ └── dummy.texi
├── dummy
├── dummy.scm
├── .gitignore
├── guix.scm
├── HACKING
├── hall.scm
├── README -> README.org
├── README.org
├── scripts
└── tests
Comme je le disais plus tôt, le fichier hall.scm est central. C'est le fichier de spécification du projet. Hall a généré cette arborescence avec la spécification suivante :
$ cat hall.scm
(hall-description
(name "dummy")
(prefix "guile")
(version "0.1")
(author "Red Nose Hacker")
(copyright (2020))
(synopsis "")
(description "")
(home-page "")
(license gpl3+)
(dependencies `())
(files (libraries
((scheme-file "dummy") (directory "dummy" ())))
(tests ((directory "tests" ())))
(programs ((directory "scripts" ())))
(documentation
((org-file "README")
(symlink "README" "README.org")
(text-file "HACKING")
(text-file "COPYING")
(directory "doc" ((texi-file "dummy")))))
(infrastructure
((scheme-file "guix")
(text-file ".gitignore")
(scheme-file "hall")))))
Scanner le projet après les premières modifications
Ajoutons un peu de code dans ce projet, par exemple une fonction avec un test.
Dans le fichier dummy.scm copier/coller le code suivant :
(define-module (dummy))
(define-public (say-hi)
"Hi hackers !")
Ensuite, créé un fichier tests/harness.scm et copie/colle le code suivant :
(define-module (tests-harness)
#:use-module (srfi srfi-64)
#:use-module (dummy))
(module-define! (resolve-module '(srfi srfi-64))
'test-log-to-file #f)
(test-begin "test-suite")
(test-equal "Greetings"
"Hi hackers !"
(say-hi))
(test-end "test-suite")
Voila, il faut maintenant que Hall soit informé de l'ajout du fichier de test.
$ hall scan --execute
Avec le scan, Hall a détecté le fichier de test et l'a ajouté dans la spécification.
(hall-description
(name "dummy")
(prefix "guile")
(version "0.1")
(author "Red Nose Hacker")
(copyright (2020))
(synopsis "")
(description "")
(home-page "")
(license gpl3+)
(dependencies `())
(files (libraries
((scheme-file "dummy") (directory "dummy" ())))
(tests ((directory "tests" ((scheme-file "harness"))))) ; <--
(programs ((directory "scripts" ())))
(documentation
((org-file "README")
(symlink "README" "README.org")
(text-file "HACKING")
(text-file "COPYING")
(directory "doc" ((texi-file "dummy")))))
(infrastructure
((scheme-file "guix") (scheme-file "hall")))))
(Bon on voit aussi que le fichier .gitignore disparait de la spec' mais... c'est pas le sujet haha).
Distribuer le projet
Avec la spécification du projet à jour, on peut maintenant générer le nécessaire pour distribuer notre logiciel.
$ hall dist --execute
Simple comme bonjour et pourtant les éléments nécessaires à autotools pour construire le projet ont été créés.
$ tree
.
├── AUTHORS
├── build-aux
│ └── test-driver.scm
├── ChangeLog
├── configure.ac
├── COPYING
├── doc
│ └── dummy.texi
├── dummy
├── dummy.scm
├── dummy.scm~
├── guix.scm
├── HACKING
├── hall.scm
├── Makefile.am
├── NEWS
├── pre-inst-env.in
├── README -> README.org
├── README.org
├── scripts
└── tests
└── harness.scm
C'est beau l'automatisation...
Construire le projet
Il est temps que je vous montre pourquoi je trouve ça cool que Hall tire profit des fonctionnalités de Guix. Bon OK, c'est bien expliqué dans le fichier HACKING mais ça me fait plaisir.
Pour construire le projet, il va vous falloir quelques bibliothèques, les fameuses dépendances. Pour les projets gérés avec Hall (v0.3.1), il faut à minima disposer de :
- autoconf
- automake
- pkg-config
- texinfo
- et guile-hall (mais on va dire que tu l'as déjà)
Si elles sont déjà installées sur ton système, cool. Sinon, il faut les installées à la main, pas cool. Mais si tu as Guix, tu peux profiter de la recette de paquet que Hall t'as concocté dans le fichier guix.scm ! En effet, tu vas pouvoir créer un environnement virtuel, qui disposera des dépendances nécessaires, pour construire le projet. Attention les yeux :
$ guix environment --load=guix.scm
Bim, quand c'est terminé, tu te retrouve dans ton environnement dédié au développement du projet dummy.
Tu peux maintenant construire et tester le projet :
[dev] $ autoreconf -vif && ./configure && make check && exit
Je te ressors l'extrait du rapport de tests, j'adore les tests :
PASS: tests/harness.scm
============================================================================
Testsuite summary for guile-dummy 0.1
============================================================================
# TOTAL: 1
# PASS: 1
# SKIP: 0
# XFAIL: 0
# FAIL: 0
# XPASS: 0
# ERROR: 0
============================================================================
Notre unique test a bien été exécuté et il est passé avec succès ! Donc notre projet peut maintenant être distribué sereinement.
Distribuer le projet
Pour distribuer (mettre à disposition, partager) du code, une pratique assez répandue est d'en faire une archive. Mais quoi mettre dans l'archive pour que nos pairs puissent le réutiliser sans problème ? Hall le sait, et il s'en charge pour toi !
$ guix environment -l guix.scm
[dev] $ make dist && exit
Nettoyer le projet
Pour les maniaques :
$ make clean && hall clean --execute
Aller plus loin
Je n'ai pas parlé de la documentation, qui est également gérée par Hall et prêt à l'emploi !
$ ./pre-inst-env info doc/dummy.texi
Je n'ai sûrement pas assez détailler l'utilisation de la commande hall. C'est pourquoi je t'encourage vivement à consulter le manuel de Hall :
$ info guile-hall
Merci beaucoup d'avoir lu cet article !
N'hésites pas à me donner ton avis, proposer une idée d'amélioration, laisser un commentaire, ou poser une question via :
– E-mail: jeremy AT korwin-zmijowski DOT fr
– Mastodon: @jeko@framapiaf.org
– Peertube: @jeko@video.tedomum.net
– Twitter: @JeremyKorwin
Abonnes-toi pour ne pas manquer les prochains :
– articles via Mastodon @jeko@write.as et RSS
– screencasts via Peertube jeko@video.tedomum.net et RSS
Et encore plus important, partages ce blog et dis à tes amis que c'est le meilleur blog de l'histoire du logiciel libre ! Sans dec'