Hall – Un gestionnaire de projet pour le langage de programmation Guile

Guile Logo

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é :

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 :

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'

#français #guile #tool #hall #guix