Journal xppq, ou une autre approche de la gestion des arguments de la ligne de commande...

xppq est un préprocesseur XML, auparavant nommé expp, qui tourne sur Linux (et probablement sous d'autres UNIX-like), OS X, et Windows, que ce soit sous architecture IA-32, x86-64 ou ARM. xppq est diffusé sous GNU AGPL. Voici les liens correspondants aux précédents journaux dédiés à son prédécesseur :

• http://linuxfr.org/users/epeios/journaux/sortie-de-la-premi%C3%A8re-version-de-expp-le-pr%C3%A9processeur-xml-du-p
• http://linuxfr.org/users/epeios/journaux/nouvelle-version-du-pr%C3%A9processeur-xml-expp
• http://linuxfr.org/users/epeios/journaux/nouvelle-version-de-expp-le-preprocesseur-xml-du-projet-epeios

À cause d'un remaniement de mon serveur, tous les liens donnés dans ces journaux n'existent plus. Mais vous trouverez leurs équivalents sur la page dédiée à xppq, qui se situe à http://q37.info/computing/epeios/tools/xppq/ (en anglais).

xppq est le premier d'une série de logiciels à venir, basés sur le framework Epeios, implémentant un nouveau système de gestion des arguments de la ligne de commande. Comme il s'agit là de la principale nouveauté de xppq (outre son changement de nom), c'est là-dessus que va porter ce journal.

En tout premier lieu, il faut savoir que tous les logiciels basés sur le framework Epeios s'appuient en interne ce qui s'appelle une registry. Cette registry est un arbre dont chaque nœud est identifié par un nom, et qui peut se voir affecter un ou plusieurs attributs. L’accès à l'un de ces nœuds se fait par des expressions à la XPath simplifié (genre Parameters/File[Type="text"]). Les valeurs stockées dans cet arbre ne sont pas typées (concrètement, chaque valeur est stockée comme une chaîne de caractère).

À titre d’exemple, supposons que l'on veuille lancer xppq sur un fichier input.xml pour générer un fichier output.xml. Pour ce faire, le logiciel a besoin d'un certains nombre de paramètres, à savoir :
- la commande à lancer,
- si le contenu généré doit être ou non indenté,
- le namespace à utiliser,
- le nom du fichier d'entrée,
- le nom du fichier de sortie.

Les valeurs de ces paramètres vont être lues par le logiciel dans la registry, dans une sous-section dont la racine à pour nom Parameters, précisément en utilisant respectivement les expressions suivantes:
- Parameters/Command
- Parameters/Indentation
- Parameters/Namespace
- Parameters/Files/Input
- Parameters/Files/Output

Ces paramètres, on va bien entendu les passer via les arguments de la ligne de commande. Cela peut être fait de la manière suivante, en utilisant une option spéciale de la forme --#<path>=<value>, ce qui donne, sachant que path est automatiquement préfixé par Parameters :

xppq --#Command=Process --#Indentation=no --#Namespace=xpp --#Files/Input=input.xml --#Files/Output=output.xml

Sachant que la registry est remplie avec le contenu d'un fichier dit de configuration, on pourra indiquer dans ce fichier les valeurs données pour les trois premiers arguments, qui deviendront de ce fait les valeurs par défaut, sachant qu'on peut utiliser une autre valeur en la redonnant comme argument de la ligne de commande. Bien que l'on puisse également donner la valeur des deux derniers arguments de la même manière, cela ne présente guère d'intérêt, le nom des fichiers d'entrée et de sortie changeant probablement souvent d'un appel à l'autre de cette commande…

Quoi qu'il en soit, passer des paramètres de cette manière n'est pas très confortable et assez éloigné de ce qui se fait habituellement, aussi va-t-on simplifier cela en définissant des raccourcis.

Pour ce faire, on va remplir une section appelée Arguments dans le fichier de configuration déjà mentionné ci-dessus. Celle-ci contiendra une ou plusieurs balise Argument dont la forme générale est la suivante :

<Argument id="..." Description="..." long="..." short="..." Path="..." Value="..." Usage="..."/>

C'est la présence ou l'absence des attributs qui détermine la nature de l'argument, sachant que les attributs id et Description devront toujours être présents.

Le raccourci concernant l'argument correspondant à la commande sera définie de la manière suivante.

<Argument id="ProcessCommand" Description="ProcessCommandDescription" long="process" Value="Process" Usage="[%NamespaceOption%] [%NoIndentationFlag%] [%PreserveFlag%] [%InputArgument% [%OutputArgument%]]"/>

Parce qu’il est absent, l'attribut Path est alors considéré comme ayant la valeur Parameters/Command. L'entrée correspondant dans la registry prendra pour valeur le contenu de l'attribut Value. Le contenu de l'attribut long, précédé par --, identifiera cet argument sur la ligne de commande. Le contenu de Usage sera utilisé pour afficher un message d'aide relatif à cette commande (plus de détails là-dessus ultérieurement). A noter que les valeur entre % sont des identifiants d’arguments (valeur de l'attribut id), arguments qui vont être définis par la suite.

Grâce à cette ligne, au lieu d'avoir à écrire :

xppq --#Command=Process ...

on va pouvoir se contenter d'écrire :

xppq --process ...

Pour gérer l’indentation, on va ajouter la ligne suivante :

<Argument id="IndentationOption" Description="IndentationOptionDescription" long="indent" Path="Indentation"/>

Ce coup-ci, on a un attribut Path, mais pas d'attribut Value. C'est cette particularité qui permet de savoir que l'on a affaire à une définition d'option. L'entrée correspondant dans la registry prendra pour valeur celle définie par l'argument correspondant de la ligne de commande. Ainsi, au lieu d'avoir à écrire :

xppq --#Indentation=(yes|no) ...

on va pouvoir écrire :

xppq --indent=(yes|no) ...

On peut également recourir, à la place d'une option, à un drapeau, en le définissant de la manière suivante :

<Argument id="NoIndentationFlag" Description="NoIndentationFlagDescription" long="no-indent" Path="Indentation" Value="No"/>

Là, on a un attribut Path, mais également un attribut Value, ce qui permet de voir que l'on a affaire à une définition de drapeau. Si, dans le fichier de configuration, on active par défaut l'indentation, pour la désactiver, au lieu d'avoir à écrire :

xppq --#Indentation=no ...

il suffira d'écrire :

xppq --no-indent ...

Pour gérer le namespace, on pourra utiliser la ligne suivante :

<Argument id="NamespaceOption" Description="NamespaceOptionDescription" long="namespace" short="n" Path="Namespace" Label="NamespaceOptionLabel"/>

On voit là un attribut short, que l'on a pas encore utilisé jusqu'à présent. A la place d'avoir à écrire :

xppq --#Namespace=xpp ...

on pourra écrire, grâce à la présence de l'attribut long (notez le double tiret --):

xppq --namespace=xpp ...

ou encore, grâce à la présence de l'attribut short (notez le simple tiret -):

xppq -n=xpp ...

La valeur de l'attribut short, s'il est présent, doit contenir un et un seul caractère.

Reste à définir les arguments qui ne sont ni une commande, ni une option et ni un drapeau. Les deux arguments correspondants à ces critères vont être définis de la manière suivante:

<Argument id="InputArgument" Description="InputArgumentDescription" Path="Files/Input" Label="InputArgumentLabel"/>
<Argument id="OutputArgument" Description="OutputArgumentDescription" Path="Files/Output" Label="OutputArgumentLabel"/>

Remarquez que de telles définitions d'arguments n'ont ni attribut long, ni attribut short.

Comme de tels arguments n'ont pas d'identifiant (-x ou --xxx, d'où l'absence d'attributs long et short dans leur définition), c’est leur position qui permet de les identifier. Pour cela, on va ajouter une section Layouts, dans la section Arguments du fichier de configuration, définie de la manière suivante :

<Layouts>
    <Layout command="Process">
        <Link index="0" Target="InputArgument"/>
        <Link index="1" Target="OutputArgument"/>
    </Layout>
</Layouts>

La valeur de l'attribut command indique quelle commande est concernée par le layout en question, étant entendu que chaque commande aura son propre layout. Dans l’exemple ci-dessus, on retrouve, pour valeur de l'attribut command, la valeur de l'attribut Value de la commande correspondante. Chaque link d'un layout donné devra avoir une valeur d'attribut index unique, et contenant des entiers successifs commençant par 0. Notez que la valeur de l'attribut Target correspond à la valeur de l'attribut id d'un des arguments précédemment définis.

Grâce à l'ensemble des ces définitions, ce qui a été précédemment écrit de la manière suivante :

xppq --#Command=Process --#Indentation=no --#Namespace=xpp --#Files/Input=input.xml --#Files/Output=output.xml

pourra être écrit de la manière suivante :

xppq --process --no-indent -n=xpp input.xml output.xml

Concernant les attributs Description, ils contiennent la chaîne de caractère de la description de l’argument correspondant dont le logiciel va afficher la traduction, telle que définie dans la section dédiée, dans la langue sélectionnée.

L'attribut Usage de la définition de l'argument de la commande contient la chaîne décrivant la syntaxe de cette commande.

Grâce à ces deux attributs, le logiciel est en mesure de générer automatiquement la page d'aide du logiciel.

Ainsi, la commande xppq --help, avec comme fichier de configuration celui à l'adresse http://hg.savannah.gnu.org/hgweb/epeios/file/d8fd9788e0fd/tools/xppq/xppq.xcfg, affichera le message suivant :

xppq --help
    Displays this page.
xppq --version
    Displays the version of the program.
xppq --license
    Displays the program license.
xppq [--process] [-n|--namespace=<ns>] [--no-indent] [--preserve] [<in> [<out>]]
    Process the XML flow.
xppq --encrypt [-n|--namespace=<ns>] [--no-indent] [--preserve] [<in> [<out>]]
    Encrypt the XML flow.

--no-indent ('Parameters/Indentation'='No'):
    No indentation.
--preserve ('Parameters/Preserve'='Yes'):
    Take account of the 'preserve' attribute from 'bloc' tag.
<ns> ('Parameters/Namespace'):
    Namespace to use (instead of 'xpp').
<in> ('Parameters/Input'):
    Input file name (use of standard input if missing).
<out> ('Parameters/Output'):
    Output file name (use of standard output if missing).

ou, en français :

xppq --help
    Affiche cette page.
xppq --version
    Affiche la version du programme.
xppq --license
    Affiche la licence du programme.
xppq [--process] [-n|--namespace=<ns>] [--no-indent] [--preserve] [<in> [<out>]]
    Traite le flux XML.
xppq --encrypt [-n|--namespace=<ns>] [--no-indent] [--preserve] [<in> [<out>]]
    Chiffre le flux XML.

--no-indent ('Parameters/Indentation'='No'):
    Pas d'indentation.
--preserve ('Parameters/Preserve'='Yes'):
    Prise en compte de l'attribut 'preserve' de la balise 'bloc'.
<ns> ('Parameters/Namespace'):
    Espace de nom à utiliser (à la place de 'xpp').
<in> ('Parameters/Input'):
    Nom du fichier d'entrée (utilisation de l'entrée standard si absent).
<out> ('Parameters/Output'):
    Nom du fichier de sortie (utilisation de la sortie standard si absent).

Cette approche me semble plus souple que celle à la getopt (qui était également ma première approche), car il y a beaucoup moins de choses à coder en dur dans le source. Cela a en outre pour conséquence d'offrir à l’utilisateur un moyen simple d'adapter les commandes/options/drapeaux à sa convenance. L'un des buts des logiciels libres, par la mise à disposition des sources, et d’offrir la possibilité à l'utilisateur d'adapter le logiciel à ses besoins. Mais si l'utilisateur peut réaliser certaines de ces adaptations sans avoir à retoucher et à recompiler le code source, je pense que c'est d'autant mieux…