From 524756d127a80beebef04b028fa73b8a99617fe0 Mon Sep 17 00:00:00 2001 From: Julien Lepiller Date: Wed, 15 Aug 2018 18:53:10 +0200 Subject: [PATCH] nls: Update 'fr' translation. --- doc/guix.fr.texi | 4152 +++++++++++++++++++++----------------- po/doc/guix-manual.fr.po | 2067 +++++++++++-------- 2 files changed, 3535 insertions(+), 2684 deletions(-) diff --git a/doc/guix.fr.texi b/doc/guix.fr.texi index 8eda0087e9..6dc7f90555 100644 --- a/doc/guix.fr.texi +++ b/doc/guix.fr.texi @@ -30,12 +30,12 @@ Leo Famulari@* Copyright @copyright{} 2015, 2016, 2017, 2018 Ricardo Wurmus@* Copyright @copyright{} 2016 Ben Woodcroft@* Copyright @copyright{} 2016, 2017, 2018 Chris Marusich@* Copyright @copyright{} 2016, 2017, 2018 Efraim Flashner@* Copyright @copyright{} 2016 John Darrington@* Copyright -@copyright{} 2016, 2017 Nils Gillmann@* Copyright @copyright{} 2016, 2017 -Jan Nieuwenhuizen@* Copyright @copyright{} 2016 Julien Lepiller@* Copyright -@copyright{} 2016 Alex ter Weele@* Copyright @copyright{} 2017, 2018 Clément -Lassieur@* Copyright @copyright{} 2017 Mathieu Othacehe@* Copyright -@copyright{} 2017 Federico Beffa@* Copyright @copyright{} 2017 Carlo -Zancanaro@* Copyright @copyright{} 2017 Thomas Danckaert@* Copyright +@copyright{} 2016, 2017 Nils Gillmann@* Copyright @copyright{} 2016, 2017, +2018 Jan Nieuwenhuizen@* Copyright @copyright{} 2016 Julien Lepiller@* +Copyright @copyright{} 2016 Alex ter Weele@* Copyright @copyright{} 2017, +2018 Clément Lassieur@* Copyright @copyright{} 2017 Mathieu Othacehe@* +Copyright @copyright{} 2017 Federico Beffa@* Copyright @copyright{} 2017 +Carlo Zancanaro@* Copyright @copyright{} 2017 Thomas Danckaert@* Copyright @copyright{} 2017 humanitiesNerd@* Copyright @copyright{} 2017 Christopher Allan Webber@* Copyright @copyright{} 2017, 2018 Marius Bakke@* Copyright @copyright{} 2017 Hartmut Goebel@* Copyright @copyright{} 2017 Maxim @@ -44,7 +44,8 @@ Copyright @copyright{} 2017 George Clemmer@* Copyright @copyright{} 2017 Andy Wingo@* Copyright @copyright{} 2017, 2018 Arun Isaac@* Copyright @copyright{} 2017 nee@* Copyright @copyright{} 2018 Rutger Helling@* Copyright @copyright{} 2018 Oleg Pykhalov@* Copyright @copyright{} 2018 Mike -Gerwitz@* Copyright @copyright{} 2018 Pierre-Antoine Rouby +Gerwitz@* Copyright @copyright{} 2018 Pierre-Antoine Rouby@* Copyright +@copyright{} 2018 Gábor Boskovits@* Vous avez la permission de copier, distribuer ou modifier ce document sous les termes de la Licence GNU Free Documentation, version 1.3 ou toute @@ -100,6 +101,15 @@ Documentation License ». Cette documentation décrit GNU Guix version @value{VERSION}, un outil de gestion de paquets fonctionnel écrit pour le système GNU@. +@c TRANSLATORS: You can replace the following paragraph with information on +@c how to join your own translation team and how to report issues with the +@c translation. +This manual is also available in French (@pxref{Top,,, guix.fr, Manuel de +référence de GNU Guix}). If you would like to translate it in your native +language, consider joining the +@uref{https://translationproject.org/domain/guix-manual.html, Translation +Project}. + @menu * Introduction:: Qu'est-ce que Guix ? * Installation:: Installer Guix. @@ -184,6 +194,7 @@ Interface de programmation * La monad du dépôt:: Interface purement fonctionnelle avec le dépôt. * G-Expressions:: Manipuler les expressions de construction. +* Invoking guix repl:: Fiddling with Guix interactively. Définition des paquets @@ -307,7 +318,7 @@ Services * Services VPN:: Démons VPN * Système de fichiers en réseau:: Services liés à NFS@. * Intégration continue:: Le service Cuirass. -* Services de gestion de l'énergie:: L'outil TLP@. +* Power Management Services:: Extending battery life. * Services audio:: MPD@. * Services de virtualisation:: Services de virtualisation. * Services de contrôle de version:: Fournit des accès distants à des @@ -497,18 +508,18 @@ L'installation se comme ceci : @enumerate @item @cindex téléchargement du Guix binaire -Téléchargez l'archive binaire depuis -@indicateurl{ftp://alpha.gnu.org/gnu/guix/guix-binary-@value{VERSION}.@var{système}.tar.xz}, -où @var{système} est @code{x86_64-linux} pour une machine @code{x86_64} sur -laquelle tourne déjà le noyau Linux, etc. +Download the binary tarball from +@indicateurl{https://alpha.gnu.org/gnu/guix/guix-binary-@value{VERSION}.@var{system}.tar.xz}, +where @var{system} is @code{x86_64-linux} for an @code{x86_64} machine +already running the kernel Linux, and so on. @c The following is somewhat duplicated in ``System Installation''. Assurez-vous de télécharger le fichier @file{.sig} associé et de vérifier l'authenticité de l'archive avec, comme ceci : @example -$ wget ftp://alpha.gnu.org/gnu/guix/guix-binary-@value{VERSION}.@var{système}.tar.xz.sig -$ gpg --verify guix-binary-@value{VERSION}.@var{système}.tar.xz.sig +$ wget https://alpha.gnu.org/gnu/guix/guix-binary-@value{VERSION}.@var{system}.tar.xz.sig +$ gpg --verify guix-binary-@value{VERSION}.@var{system}.tar.xz.sig @end example Si cette commande échoue parce que vous n'avez pas la clef publique requise, @@ -695,8 +706,8 @@ ultérieure, dont 2.2.x, (@pxref{Guile Preparations, how to install the GnuTLS bindings for Guile,, gnutls-guile, GnuTLS-Guile}), @item -@c FIXME: Specify a version number once a release has been made. -@uref{https://notabug.org/civodul/guile-sqlite3, Guile-SQLite3} ; +@uref{https://notabug.org/civodul/guile-sqlite3, Guile-SQLite3}, version +0.1.0 or later; @item @c FIXME: Specify a version number once a release has been made. @uref{https://gitlab.com/guile-git/guile-git, Guile-Git}, d'août 2017 ou @@ -1081,8 +1092,8 @@ Il y a un certain nombre de champs facultatifs que vous pouvez remplir : Numéro de port du serveur SSH sur la machine. @item @code{private-key} (par défaut : @file{~root/.ssh/id_rsa}) -Le fichier de clef privée à utiliser lors de la connexion à la machine, au -format OpenSSH@. +The SSH private key file to use when connecting to the machine, in OpenSSH +format. This key must not be protected with a passphrase. Remarquez que la valeur par défaut est la clef privée @emph{du compte root}. Assurez-vous qu'elle existe si vous utilisez la valeur par défaut. @@ -1469,11 +1480,10 @@ utilisées. @cindex racines du GC @cindex racines du ramasse-miettes -Lorsqu'elle est à « yes », le GC gardera les sorties de toutes les -dérivations — les fichiers @code{.drv} — utilisées dans le dépôt. La valeur -par défaut est « no », ce qui signifie que les sorties des dérivations ne -sont gardées que s'il s'agit de racines du GC@. @xref{Invoquer guix gc} -pour plus d'informations sur les racines du GC@. +When set to ``yes'', the GC will keep the outputs of any live derivation +available in the store---the @code{.drv} files. The default is ``no'', +meaning that derivation outputs are kept only if they are reachable from a +GC root. @xref{Invoquer guix gc}, for more on GC roots. @item --gc-keep-derivations[=yes|no] Dire si le ramasse-miettes (GC) doit garder les dérivations correspondant à @@ -1485,12 +1495,14 @@ leurs sorties est utilisée. Cela permet aux utilisateurs de garder une trace de l'origine des éléments du dépôt. Le mettre à « no » préserve un peu d'espace disque. -Remarquez qu'avec @code{--gc-keep-derivations} et @code{--gc-keep-outputs}, -le GC gardera tous les prérequis de construction (les sources, le -compilateur, les bibliothèques, et les autres outils de construction) des -objets utilisés dans le dépôt, indépendamment du fait qu'ils soient ou non -utilisés. Cela est pratique pour les développeurs car ça leur fait gagner -du temps de reconstruction et de téléchargement. +In this way, setting @code{--gc-keep-derivations} to ``yes'' causes liveness +to flow from outputs to derivations, and setting @code{--gc-keep-outputs} to +``yes'' causes liveness to flow from derivations to outputs. When both are +set to ``yes'', the effect is to keep all the build prerequisites (the +sources, compiler, libraries, and other build-time tools) of live objects in +the store, regardless of whether these prerequisites are reachable from a GC +root. This is convenient for developers since it saves rebuilds or +downloads. @item --impersonate-linux-2.6 Sur les système basés sur Linux, se faire passer pour Linux 2.6. Cela @@ -2562,7 +2574,7 @@ serveur, la connexion peut avoir été interrompue, etc. Lorsque les substituts sont activés et qu'un substitut pour une dérivation est disponible, mais que la tentative de substitution échoue, Guix essaiera de construire la dérivation localement si @code{--fallback} a été passé en -argument (@pxref{fallback-option,, common build option @code{--fallback}}). +argument (@pxref{option de repli,, common build option @code{--fallback}}). Plus spécifiquement, si cet option n'a pas été passée en argument, alors aucune construction locale n'est effectuée et la dérivation est considérée comme étant en échec. Cependant, si @code{--fallback} est passé en argument, @@ -2603,7 +2615,7 @@ développeurs à trouver les constructions de paquets non-déterministes (@pxref{Invoquer guix challenge}). De même, l'option @option{--check} de @command{guix build} permet aux utilisateurs de vérifier si les substituts précédemment installés sont authentiques en les reconstruisant localement -(@pxref{build-check, @command{guix build --check}}). +(@pxref{vérification de la construction, @command{guix build --check}}). Dans le futur, nous aimerions que Guix puisse publier et recevoir des binaires d'autres utilisateurs, d'une manière pair-à-pair. Si vous voulez @@ -2907,17 +2919,23 @@ Génération 1 10 juin 2018 00:18:18 branche : origin/master commit : 65956ad3526ba09e1f7a40722c96c6ef7c0936fe -Génération 2 11 juin 2018 11:02:49 +Generation 2 Jun 11 2018 11:02:49 guix e0cc7f6 - URL du dépôt : https://git.savannah.gnu.org/git/guix.git - branche : origin/master - commit : e0cc7f669bec22c37481dd03a7941c7d11a64f1d + repository URL: https://git.savannah.gnu.org/git/guix.git + branch: origin/master + commit: e0cc7f669bec22c37481dd03a7941c7d11a64f1d + 2 new packages: keepalived, libnfnetlink + 6 packages upgraded: emacs-nix-mode@@2.0.4, + guile2.0-guix@@0.14.0-12.77a1aac, guix@@0.14.0-12.77a1aac, + heimdal@@7.5.0, milkytracker@@1.02.00, nix@@2.0.4 -Génération 3 13 juin 2018 23:31:07 (actuelle) +Generation 3 Jun 13 2018 23:31:07 (current) guix 844cc1c - URL du dépôt : https://git.savannah.gnu.org/git/guix.git - branche : origin/master - commit : 844cc1c8f394f03b404c5bb3aee086922373490c + repository URL: https://git.savannah.gnu.org/git/guix.git + branch: origin/master + commit: 844cc1c8f394f03b404c5bb3aee086922373490c + 28 new packages: emacs-helm-ls-git, emacs-helm-mu, @dots{} + 69 packages upgraded: borg@@1.1.6, cheese@@3.28.0, @dots{} @end example Ce profil @code{~/.config/guix/current} fonctionne comme les autres profils @@ -3407,6 +3425,7 @@ paquets à haut-niveau. * La monad du dépôt:: Interface purement fonctionnelle avec le dépôt. * G-Expressions:: Manipuler les expressions de construction. +* Invoking guix repl:: Fiddling with Guix interactively. @end menu @node Définition des paquets @@ -4199,6 +4218,21 @@ construction. Le paquet @code{glib} qui fournit Ces deux phases sont exécutées après la phase @code{install}. @end defvr +@defvr {Scheme Variable} guile-build-system +This build system is for Guile packages that consist exclusively of Scheme +code and that are so lean that they don't even have a makefile, let alone a +@file{configure} script. It compiles Scheme code using @command{guild +compile} (@pxref{Compilation,,, guile, GNU Guile Reference Manual}) and +installs the @file{.scm} and @file{.go} files in the right place. It also +installs documentation. + +This build system supports cross-compilation by using the @code{--target} +option of @command{guild compile}. + +Packages built with @code{guile-build-system} must provide a Guile package +in their @code{native-inputs} field. +@end defvr + @defvr {Variable Scheme} minify-build-system Cette variable est exportée par @code{(guix build-system minify)}. Elle implémente une procédure de minification pour des paquets JavaScript @@ -4783,45 +4817,50 @@ construction en Scheme, bien sur ! Le mieux à faire pour cela est d'écrire le code de construction comme une « G-expression » et de la passer à @code{gexp->derivation}. Pour plus d'informations, @pxref{G-Expressions}. -Once upon a time, @code{gexp->derivation} did not exist and constructing -derivations with build code written in Scheme was achieved with -@code{build-expression->derivation}, documented below. This procedure is -now deprecated in favor of the much nicer @code{gexp->derivation}. +Il fut un temps où @code{gexp->derivation} n'existait pas et où construire +une dérivation donc le code de construction était écrit en Scheme se faisait +avec @code{build-expression->derivation}, documenté plus bas. Cette +procédure est maintenant obsolète, remplacée par @code{gexp->derivation} qui +est meilleure. -@deffn {Scheme Procedure} build-expression->derivation @var{store} @ - @var{name} @var{exp} @ [#:system (%current-system)] [#:inputs '()] @ -[#:outputs '("out")] [#:hash #f] [#:hash-algo #f] @ [#:recursive? #f] -[#:env-vars '()] [#:modules '()] @ [#:references-graphs #f] -[#:allowed-references #f] @ [#:disallowed-references #f] @ [#:local-build? -#f] [#:substitutable? #t] [#:guile-for-build #f] Return a derivation that -executes Scheme expression @var{exp} as a builder for derivation -@var{name}. @var{inputs} must be a list of @code{(name drv-path sub-drv)} -tuples; when @var{sub-drv} is omitted, @code{"out"} is assumed. -@var{modules} is a list of names of Guile modules from the current search -path to be copied in the store, compiled, and made available in the load -path during the execution of @var{exp}---e.g., @code{((guix build utils) -(guix build gnu-build-system))}. +@deffn {Procédure Scheme} build-expression->derivation @var{store} @ + @var{name} @var{exp} @ +[#:system (%current-system)] [#:inputs '()] @ +[#:outputs '("out")] [#:hash #f] [#:hash-algo #f] @ +[#:recursive? #f] [#:env-vars '()] [#:modules '()] @ +[#:references-graphs #f] [#:allowed-references #f] @ +[#:disallowed-references #f] @ +[#:local-build? #f] [#:substitutable? #t] [#:guile-for-build #f] +Renvoie une dérivation qui exécute l'expression Scheme @var{exp} comme un +constructeur pour la dérivation @var{name}. @var{inputs} doit être une +liste de tuples @code{(name drv-path sub-drv)} ; lorsque @var{sub-drv} est +omis, @code{"out"} est utilisé. @var{modules} est une liste de noms de +modules Guile du chemin de recherche actuel qui seront copiés dans le dépôt, +compilés et rendus disponibles dans le chemin de chargement pendant +l'exécution de @var{exp} — p.@: ex.@: @code{((guix build utils) (guix build +gnu-build-system))}. -@var{exp} is evaluated in an environment where @code{%outputs} is bound to a -list of output/path pairs, and where @code{%build-inputs} is bound to a list -of string/output-path pairs made from @var{inputs}. Optionally, -@var{env-vars} is a list of string pairs specifying the name and value of -environment variables visible to the builder. The builder terminates by -passing the result of @var{exp} to @code{exit}; thus, when @var{exp} returns -@code{#f}, the build is considered to have failed. +@var{exp} est évaluée dans une environnement où @code{%outputs} est lié à +une liste de paires de sortie/chemin, et où @code{%build-inputs} est lié à +une liste de paires de chaînes de caractères et de chemin de sortie +construite à partir de @var{inputs}. Éventuellement, @var{env-vars} est une +liste de paires de chaînes de caractères spécifiant le nom et la valeur de +variables d'environnement visibles pour le constructeur. Le constructeur +termine en passant le résultat de @var{exp} à @code{exit} ; ainsi, lorsque +@var{exp} renvoie @code{#f}, la construction est considérée en échec. -@var{exp} is built using @var{guile-for-build} (a derivation). When -@var{guile-for-build} is omitted or is @code{#f}, the value of the -@code{%guile-for-build} fluid is used instead. +@var{exp} est construite avec @var{guile-for-build} (une dérivation). +Lorsque @var{guile-for-build} est omis où est @code{#f}, la valeur du fluide +@code{%guile-for-build} est utilisée à la place. -See the @code{derivation} procedure for the meaning of -@var{references-graphs}, @var{allowed-references}, -@var{disallowed-references}, @var{local-build?}, and @var{substitutable?}. +Voir la procédure @code{derivation} pour la signification de +@var{references-graph}, @var{allowed-references}, +@var{disallowed-references}, @var{local-build?} et @var{substitutable?}. @end deffn @noindent -Here's an example of a single-output derivation that creates a directory -containing one file: +Voici un exemple de dérivation à sortie unique qui crée un répertoire avec +un fichier : @lisp (let ((builder '(let ((out (assoc-ref %outputs "out"))) @@ -4840,33 +4879,36 @@ containing one file: @cindex monad -The procedures that operate on the store described in the previous sections -all take an open connection to the build daemon as their first argument. -Although the underlying model is functional, they either have side effects -or depend on the current state of the store. +Les procédures qui travaillent sur le dépôt décrites dans les sections +précédentes prennent toutes une connexion ouverte au démon de construction +comme premier argument. Bien que le modèle sous-jacent soit fonctionnel, +elles ont soit des effets de bord, soit dépendent de l'état actuel du dépôt. -The former is inconvenient: the connection to the build daemon has to be -carried around in all those functions, making it impossible to compose -functions that do not take that parameter with functions that do. The -latter can be problematic: since store operations have side effects and/or -depend on external state, they have to be properly sequenced. +Le premier point est embêtant : on doit se balader avec la connexion au +démon dans toutes ces fonctions, ce qui rend impossible le fait de composer +des fonctions qui ne prennent pas ce paramètre avec des fonctions qui le +prennent. Le deuxième point est problématique : comme les opérations sur le +dépôt ont des effets de bord ou dépendent d'états externes, elles doivent +être enchaînés correctement. -@cindex monadic values -@cindex monadic functions -This is where the @code{(guix monads)} module comes in. This module -provides a framework for working with @dfn{monads}, and a particularly -useful monad for our uses, the @dfn{store monad}. Monads are a construct -that allows two things: associating ``context'' with values (in our case, -the context is the store), and building sequences of computations (here -computations include accesses to the store). Values in a monad---values -that carry this additional context---are called @dfn{monadic values}; -procedures that return such values are called @dfn{monadic procedures}. +@cindex valeurs monadiques +@cindex fonctions monadiques +C'est là que le module @code{(guix monads)} arrive à la rescousse. Ce +module fournit un cadre pour travailler avec des @dfn{monads}, en +particulier une monad très utile pour notre usage, la @dfn{monad du dépôt}. +Les monads sont des constructions qui permettent deux choses : associer un « +contexte » avec une valeur (dans notre cas, le contexte est le dépôt) et +construire une séquence de calculs (ici les calculs comprennent des accès au +dépôt). Les valeurs dans une monad — les valeurs qui contiennent ce +contexte supplémentaire — sont appelées des @dfn{valeurs monadiques} ; les +procédures qui renvoient ce genre de valeur sont appelées des +@dfn{procédures monadiques}. -Consider this ``normal'' procedure: +Considérez cette procédure « normale » : @example (define (sh-symlink store) - ;; Return a derivation that symlinks the 'bash' executable. + ;; Renvoie une dérivation qui crée un lien symbolique vers l'exécutable « bash ». (let* ((drv (package-derivation store bash)) (out (derivation->output-path drv)) (sh (string-append out "/bin/bash"))) @@ -4874,27 +4916,28 @@ Consider this ``normal'' procedure: `(symlink ,sh %output)))) @end example -Using @code{(guix monads)} and @code{(guix gexp)}, it may be rewritten as a -monadic function: +En utilisant @code{(guix monads)} et @code{(guix gexp)}, on peut la réécrire +en une fonction monadique : @example (define (sh-symlink) - ;; Same, but return a monadic value. + ;; Pareil, mais renvoie une valeur monadique. (mlet %store-monad ((drv (package->derivation bash))) (gexp->derivation "sh" #~(symlink (string-append #$drv "/bin/bash") #$output)))) @end example -There are several things to note in the second version: the @code{store} -parameter is now implicit and is ``threaded'' in the calls to the -@code{package->derivation} and @code{gexp->derivation} monadic procedures, -and the monadic value returned by @code{package->derivation} is @dfn{bound} -using @code{mlet} instead of plain @code{let}. +Il y a plusieurs choses à remarquer avec cette deuxième version : le +paramètre @code{store} est maintenant implicitement « enfilé » dans les +appels aux procédures monadiques @code{package->derivation} et +@code{gexp->derivation}, et la valeur monadique renvoyée par +@code{package->derivation} est @dfn{liée} avec @code{mlet} plutôt qu'avec un +simple @code{let}. -As it turns out, the call to @code{package->derivation} can even be omitted -since it will take place implicitly, as we will see later -(@pxref{G-Expressions}): +Il se trouve que l'appel à @code{package->derivation} peut même être omis +puisqu'il aura lieu implicitement, comme nous le verrons plus tard +(@pxref{G-Expressions}) : @example (define (sh-symlink) @@ -4906,28 +4949,32 @@ since it will take place implicitly, as we will see later @c See @c @c for the funny quote. -Calling the monadic @code{sh-symlink} has no effect. As someone once said, -``you exit a monad like you exit a building on fire: by running''. So, to -exit the monad and get the desired effect, one must use -@code{run-with-store}: +L'appel à la procédure monadique @code{sh-symlink} n'a aucun effet. En +anglais on pourrait dire « you exit a monad like you exit a building on +fire: by running »@footnote{NdT : « on sort d'une monad comme d'un immeuble +en flamme, en courant ». Le jeu de mot est perdu à la traduction : courrir +et lancer utilisent le même verbe @i{run} en anglais.}. Donc, pour sortir de +la monad et obtenir l'effet escompté, on doit utiliser +@code{run-with-store}. @example (run-with-store (open-connection) (sh-symlink)) @result{} /gnu/store/...-sh-symlink @end example -Note that the @code{(guix monad-repl)} module extends the Guile REPL with -new ``meta-commands'' to make it easier to deal with monadic procedures: -@code{run-in-store}, and @code{enter-store-monad}. The former is used to -``run'' a single monadic value through the store: +Remarquez que le module @code{(guix monad-repl)} étend la console Guile avec +de nouvelles « méta-commandes » pour rendre plus facile la manipulation de +procédures monadiques : @code{run-in-store} et @code{enter-store-monad}. La +première est utilisée pour « lancer » une seule valeur monadique à travers +le dépôt : @example scheme@@(guile-user)> ,run-in-store (package->derivation hello) $1 = # @dots{}> @end example -The latter enters a recursive REPL, where all the return values are -automatically run through the store: +La deuxième entre dans une console récursive, où toutes les valeurs de +retour sont automatiquement lancées à travers le dépôt : @example scheme@@(guile-user)> ,enter-store-monad @@ -4940,27 +4987,28 @@ scheme@@(guile-user)> @end example @noindent -Note that non-monadic values cannot be returned in the @code{store-monad} -REPL. +Remarquez qu'on ne peut pas renvoyer de valeur non monadique dans la console +@code{store-monad}. -The main syntactic forms to deal with monads in general are provided by the -@code{(guix monads)} module and are described below. +Les formes syntaxiques principales pour utiliser des monads en général sont +disponibles dans le module @code{(guix monads)} et sont décrites ci-dessous. -@deffn {Scheme Syntax} with-monad @var{monad} @var{body} ... -Evaluate any @code{>>=} or @code{return} forms in @var{body} as being in -@var{monad}. +@deffn {Syntaxe Scheme} with-monad @var{monad} @var{body} ... +Évalue n'importe quelle forme @code{>>=} ou @code{return} dans @var{body} +comme une @var{monad}. @end deffn -@deffn {Scheme Syntax} return @var{val} -Return a monadic value that encapsulates @var{val}. +@deffn {Syntaxe Scheme} return @var{val} +Renvoie une valeur monadique qui encapsule @var{val}. @end deffn -@deffn {Scheme Syntax} >>= @var{mval} @var{mproc} ... -@dfn{Bind} monadic value @var{mval}, passing its ``contents'' to monadic -procedures @var{mproc}@dots{}@footnote{This operation is commonly referred -to as ``bind'', but that name denotes an unrelated procedure in Guile. Thus -we use this somewhat cryptic symbol inherited from the Haskell language.}. -There can be one @var{mproc} or several of them, as in this example: +@deffn {Syntaxe Scheme} >>= @var{mval} @var{mproc} ... +@dfn{Lie} une valeur monadique @var{mval}, en passant son « contenu » aux +procédures monadiques @var{mproc}@dots{}@footnote{Cette opération est +souvent appelée « bind », mais ce nom dénote une procédure qui n'a rien à +voir en Guile. Ainsi, nous empruntons ce symbole quelque peu cryptique au +langage Haskell}. Il peut y avoir une ou plusieurs @code{mproc}, comme dans +cet exemple : @example (run-with-state @@ -4975,60 +5023,63 @@ There can be one @var{mproc} or several of them, as in this example: @end example @end deffn -@deffn {Scheme Syntax} mlet @var{monad} ((@var{var} @var{mval}) ...) @ +@deffn {Syntaxe Scheme} mlet @var{monad} ((@var{var} @var{mval}) ...) @ @var{body} ... -@deffnx {Scheme Syntax} mlet* @var{monad} ((@var{var} @var{mval}) ...) @ - @var{body} ... Bind the variables @var{var} to the monadic values -@var{mval} in @var{body}, which is a sequence of expressions. As with the -bind operator, this can be thought of as ``unpacking'' the raw, non-monadic -value ``contained'' in @var{mval} and making @var{var} refer to that raw, -non-monadic value within the scope of the @var{body}. The form (@var{var} --> @var{val}) binds @var{var} to the ``normal'' value @var{val}, as per -@code{let}. The binding operations occur in sequence from left to right. -The last expression of @var{body} must be a monadic expression, and its -result will become the result of the @code{mlet} or @code{mlet*} when run in -the @var{monad}. +@deffnx {Syntaxe Scheme} mlet* @var{monad} ((@var{var} @var{mval}) ...) @ + @var{body} ... +Lie les variables @var{var} aux valeurs monadiques @var{mval} dans +@var{body}, une séquence d'expressions. Comme avec l'opérateur de liaison, +on peut réfléchir comme si on « ouvrait » la valeur non-monadique « contenue +» dans @var{mval} et comme si on faisait en sorte que @var{var} se réfère à +cette valeur pure, non-monadique, dans la portée de @var{body}. La forme +(@var{var} -> @var{val}) lie @var{var} à la valeur « normale » @var{val}, +comme @code{let}. L'opération de liaison a lieu en séquence de la gauche +vers la droite. La dernière expression de @var{body} doit être une +expression monadique et son résultat deviendra le résultat de @code{mlet} ou +@code{mlet*} lorsque lancé dans la @var{monad}. -@code{mlet*} is to @code{mlet} what @code{let*} is to @code{let} +@code{mlet*} est à @code{mlet} ce que @code{let*} est à @code{let} (@pxref{Local Bindings,,, guile, GNU Guile Reference Manual}). @end deffn -@deffn {Scheme System} mbegin @var{monad} @var{mexp} ... -Bind @var{mexp} and the following monadic expressions in sequence, returning -the result of the last expression. Every expression in the sequence must be -a monadic expression. +@deffn {Système Scheme} mbegin @var{monad} @var{mexp} ... +Lie @var{mexp} et les expressions monadiques suivantes en séquence, et +renvoie le résultat de la dernière expression. Chaque expression dans la +séquence doit être une expression monadique. -This is akin to @code{mlet}, except that the return values of the monadic -expressions are ignored. In that sense, it is analogous to @code{begin}, -but applied to monadic expressions. +Cette procédure est similaire à @code{mlet}, sauf que les valeurs de retour +des expressions monadiques sont ignorées. Dans ce sens, elle est analogue à +@code{begin}, mais appliqué à des expressions monadiques. @end deffn -@deffn {Scheme System} mwhen @var{condition} @var{mexp0} @var{mexp*} ... -When @var{condition} is true, evaluate the sequence of monadic expressions -@var{mexp0}..@var{mexp*} as in an @code{mbegin}. When @var{condition} is -false, return @code{*unspecified*} in the current monad. Every expression -in the sequence must be a monadic expression. +@deffn {Système Scheme} mwhen @var{condition} @var{mexp0} @var{mexp*} ... +Lorsque la @var{condition} est vraie, évalue la séquence des expressions +monadiques @var{mexp0}..@var{mexp*} comme dans un @code{mbegin}. Lorsque la +@var{condition} est fausse, renvoie @code{*unspecified*} dans la monad +actuelle. Cahque expression dans la séquence doit être une expression +monadique. @end deffn -@deffn {Scheme System} munless @var{condition} @var{mexp0} @var{mexp*} ... -When @var{condition} is false, evaluate the sequence of monadic expressions -@var{mexp0}..@var{mexp*} as in an @code{mbegin}. When @var{condition} is -true, return @code{*unspecified*} in the current monad. Every expression in -the sequence must be a monadic expression. +@deffn {Système Scheme} munless @var{condition} @var{mexp0} @var{mexp*} ... +Lorsque la @var{condition} est fausse, évalue la séquence des expressions +monadiques @var{mexp0}..@var{mexp*} comme dans un @code{mbegin}. Lorsque la +@var{condition} est vraie, renvoie @code{*unspecified*} dans la monad +actuelle. Cahque expression dans la séquence doit être une expression +monadique. @end deffn -@cindex state monad -The @code{(guix monads)} module provides the @dfn{state monad}, which allows -an additional value---the state---to be @emph{threaded} through monadic -procedure calls. +@cindex monad d'état +Le module @code{(guix monads)} fournit la @dfn{monad d'état} qui permet à +une valeur supplémentaire — l'état — d'être enfilée à travers les appels de +procédures. -@defvr {Scheme Variable} %state-monad -The state monad. Procedures in the state monad can access and change the -state that is threaded. +@defvr {Variable Scheme} %state-monad +La monad d'état. les procédure dans la monad d'état peuvent accéder et +modifier l'état qui est enfilé. -Consider the example below. The @code{square} procedure returns a value in -the state monad. It returns the square of its argument, but also increments -the current state value: +Considérez l'exemple ci-dessous. La procédure @code{square} renvoie une +valeur dans la monad d'état. Elle renvoie le carré de son argument, mais +incrémente aussi la valeur actuelle de l'état : @example (define (square x) @@ -5042,71 +5093,82 @@ the current state value: @result{} 3 @end example -When ``run'' through @var{%state-monad}, we obtain that additional state -value, which is the number of @code{square} calls. +Lorsqu'on la lance à travers @var{%state-monad}, on obtient cet valeur +d'état supplémentaire, qui est le nombre d'appels à @code{square}. @end defvr -@deffn {Monadic Procedure} current-state -Return the current state as a monadic value. +@deffn {Procédure Monadic} current-state +Renvoie l'état actuel dans une valeur monadique. @end deffn -@deffn {Monadic Procedure} set-current-state @var{value} -Set the current state to @var{value} and return the previous state as a -monadic value. +@deffn {Procédure Monadic} set-current-state @var{value} +Initialise l'état actuel à @var{value} et renvoie l'état précédent dans une +valeur monadique. @end deffn -@deffn {Monadic Procedure} state-push @var{value} -Push @var{value} to the current state, which is assumed to be a list, and -return the previous state as a monadic value. +@deffn {Procédure Monadic} state-push @var{value} +Pousse @var{value} sur l'état actuel, qui est supposé être une liste, et +renvoie l'état précédent dans une valeur monadique. @end deffn -@deffn {Monadic Procedure} state-pop -Pop a value from the current state and return it as a monadic value. The -state is assumed to be a list. +@deffn {Procédure Monadic} state-pop +Récupère (pop) une valeur dans l'état actuel et la renvoie comme une valeur +monadique. L'état est supposé être une liste. @end deffn -@deffn {Scheme Procedure} run-with-state @var{mval} [@var{state}] -Run monadic value @var{mval} starting with @var{state} as the initial -state. Return two values: the resulting value, and the resulting state. +@deffn {Procédure Scheme} run-with-state @var{mval} [@var{state}] +Lance la valeur monadique @var{mval} avec @var{state} comme valeur +initiale. Renvoie deux valeurs : la valeur du résultat et l'état du +résultat. @end deffn -The main interface to the store monad, provided by the @code{(guix store)} -module, is as follows. +L'interface principale avec la monad du dépôt, fournit par le module +@code{(guix store)}, est la suivante. -@defvr {Scheme Variable} %store-monad -The store monad---an alias for @var{%state-monad}. +@defvr {Variable Scheme} %store-monad +La monad du dépôt — un alias pour @var{%state-monad}. -Values in the store monad encapsulate accesses to the store. When its -effect is needed, a value of the store monad must be ``evaluated'' by -passing it to the @code{run-with-store} procedure (see below.) +Les valeurs dans la monad du dépôt encapsulent des accès au dépôt. Lorsque +son effet est requis, une valeur de la monad du dépôt doit être « évaluée » +en la passant à la procédure @code{run-with-store} (voir plus bas). @end defvr -@deffn {Scheme Procedure} run-with-store @var{store} @var{mval} [#:guile-for-build] [#:system (%current-system)] -Run @var{mval}, a monadic value in the store monad, in @var{store}, an open -store connection. +@deffn {Procédure Scheme} run-with-store @var{store} @var{mval} [#:guile-for-build] [#:system (%current-system)] +Lance @var{mval}, une valeur monadique dans la monad du dépôt, dans +@var{store}, une connexion ouvert au dépôt. @end deffn -@deffn {Monadic Procedure} text-file @var{name} @var{text} [@var{references}] +@deffn {Procédure Monadique} text-file @var{name} @var{text} [@var{references}] +Renvoie une valeur monadique correspondant au nom de fichier dans le dépôt +du fichier contenant @var{text}, une chaîne de caractères. @var{references} +est une liste d'éléments du dépôt auxquels le fichier texte en résultat se +réfère ; c'est la liste vide par défaut. +@end deffn + +@deffn {Monadic Procedure} binary-file @var{name} @var{data} [@var{references}] Return as a monadic value the absolute file name in the store of the file -containing @var{text}, a string. @var{references} is a list of store items -that the resulting text file refers to; it defaults to the empty list. +containing @var{data}, a bytevector. @var{references} is a list of store +items that the resulting binary file refers to; it defaults to the empty +list. @end deffn -@deffn {Monadic Procedure} interned-file @var{file} [@var{name}] @ - [#:recursive? #t] [#:select? (const #t)] Return the name of @var{file} once -interned in the store. Use @var{name} as its store name, or the basename of -@var{file} if @var{name} is omitted. +@deffn {Procédure Monadique} interned-file @var{file} [@var{name}] @ + [#:recursive? #t] [#:select? (const #t)] +Renvoie le nom de @var{file} une fois ajouté au dépôt. Utilise @var{name} +comme nom dans le dépôt ou le nom de fichier de @var{file} si @var{name} est +omis. -When @var{recursive?} is true, the contents of @var{file} are added -recursively; if @var{file} designates a flat file and @var{recursive?} is -true, its contents are added, and its permission bits are kept. +Lorsque @var{recursive?} est vraie, le contenu de @var{file} est ajouté +récursivement ; si @var{file} désigne un fichier simple et que +@var{recursive?} est vrai, son contenu est ajouté et ses bits de permissions +sont préservés. -When @var{recursive?} is true, call @code{(@var{select?} @var{file} -@var{stat})} for each directory entry, where @var{file} is the entry's -absolute file name and @var{stat} is the result of @code{lstat}; exclude -entries for which @var{select?} does not return true. +Lorsque @var{recursive?} est vraie, appelle @code{(@var{select?} @var{file} +@var{stat})} pour chaque répertoire où @var{file} est le nom de fichier +absolu de l'entrée et @var{stat} est le résultat de @code{lstat} ; à +l'exception des entrées pour lesquelles @var{select?} ne renvoie pas vrai. -The example below adds a file to the store, under two different names: +L'exemple ci-dessous ajoute un fichier au dépôt, sous deux noms différents : @example (run-with-store (open-connection) @@ -5119,20 +5181,23 @@ The example below adds a file to the store, under two different names: @end deffn -The @code{(guix packages)} module exports the following package-related -monadic procedures: +Le module @code{(guix packages)} exporte les procédures monadiques liées aux +paquets suivantes : -@deffn {Monadic Procedure} package-file @var{package} [@var{file}] @ - [#:system (%current-system)] [#:target #f] @ [#:output "out"] Return as a -monadic value in the absolute file name of @var{file} within the -@var{output} directory of @var{package}. When @var{file} is omitted, return -the name of the @var{output} directory of @var{package}. When @var{target} -is true, use it as a cross-compilation target triplet. +@deffn {Procédure Monadique} package-file @var{package} [@var{file}] @ + [#:system (%current-system)] [#:target #f] @ +[#:output "out"] +Renvoie une valeur monadique qui contient le nom de fichier absolu de +@var{file} dans le répertoire @var{output} de @var{package}. Lorsque +@var{file} est omis, renvoie le nom du répertoire @var{output} de +@var{package}. Lorsque @var{target} est vrai, l'utilise comme un triplet de +cible pour la compilation croisée. @end deffn -@deffn {Monadic Procedure} package->derivation @var{package} [@var{system}] -@deffnx {Monadic Procedure} package->cross-derivation @var{package} @ - @var{target} [@var{system}] Monadic version of @code{package-derivation} and +@deffn {Procédure Monadique} package->derivation @var{package} [@var{system}] +@deffnx {Procédure Monadique} package->cross-derivation @var{package} @ + @var{target} [@var{system}] +Version monadique de @code{package-derivation} et @code{package-cross-derivation} (@pxref{Définition des paquets}). @end deffn @@ -5141,64 +5206,69 @@ is true, use it as a cross-compilation target triplet. @section G-Expressions @cindex G-expression -@cindex build code quoting -So we have ``derivations'', which represent a sequence of build actions to -be performed to produce an item in the store (@pxref{Dérivations}). These -build actions are performed when asking the daemon to actually build the -derivations; they are run by the daemon in a container (@pxref{Invoquer guix-daemon}). +@cindex quoting du code de construction +On a donc des « dérivations » qui représentent une séquence d'actions de +construction à effectuer pour produire un élément du dépôt +(@pxref{Dérivations}). Ces actions de construction sont effectuées +lorsqu'on demande au démon de construire effectivement les dérivations ; +elles sont lancées par le démon dans un conteneur (@pxref{Invoquer guix-daemon}). -@cindex strata of code -It should come as no surprise that we like to write these build actions in -Scheme. When we do that, we end up with two @dfn{strata} of Scheme -code@footnote{The term @dfn{stratum} in this context was coined by Manuel -Serrano et al.@: in the context of their work on Hop. Oleg Kiselyov, who -has written insightful -@url{http://okmij.org/ftp/meta-programming/#meta-scheme, essays and code on -this topic}, refers to this kind of code generation as @dfn{staging}.}: the -``host code''---code that defines packages, talks to the daemon, etc.---and -the ``build code''---code that actually performs build actions, such as -making directories, invoking @command{make}, etc. +@cindex strate de code +Ça ne devrait pas vous surprendre, mais nous aimons écrire ces actions de +construction en Scheme. Lorsqu'on fait ça, on fini avec deux @dfn{strates} +de code Scheme@footnote{Le terme @dfn{strate} dans ce contexte a été inventé +par Manuel Serrano et ses collaborateurs dans le contexte de leur travaux +sur Hop. Oleg Kiselyov, qui a écrit des +@url{http://okmij.org/ftp/meta-programming/#meta-scheme, essais perspicaces +et du code sur le sujet}, utilise le terme de « mise en scène » pour ce +genre de génération de code.} : le « code hôte » — le code qui défini les +paquets, parle au démon, etc — et le « code côté construction » — le code +qui effectue effectivement les actions de construction, comme créer des +répertoires, invoquer @code{make}, etc. -To describe a derivation and its build actions, one typically needs to embed -build code inside host code. It boils down to manipulating build code as -data, and the homoiconicity of Scheme---code has a direct representation as -data---comes in handy for that. But we need more than the normal -@code{quasiquote} mechanism in Scheme to construct build expressions. +Pour décrire une dérivation et ses actions de construction, on a typiquement +besoin d'intégrer le code de construction dans le code hôte. Ça revient à +manipuler le code de construction comme de la donnée, et l'homoiconicité de +Scheme — le code a une représentation directe en tant que donnée — est très +utile pour cela. Mais on a besoin de plus que le mécanisme de +@code{quasiquote} en Scheme pour construire des expressions de construction. -The @code{(guix gexp)} module implements @dfn{G-expressions}, a form of -S-expressions adapted to build expressions. G-expressions, or @dfn{gexps}, -consist essentially of three syntactic forms: @code{gexp}, @code{ungexp}, -and @code{ungexp-splicing} (or simply: @code{#~}, @code{#$}, and -@code{#$@@}), which are comparable to @code{quasiquote}, @code{unquote}, and -@code{unquote-splicing}, respectively (@pxref{Expression Syntax, -@code{quasiquote},, guile, GNU Guile Reference Manual}). However, there are -major differences: +Le module @code{(guix gexp)} implémente les @dfn{G-expressions}, une forme +de S-expression adaptée aux expressions de construction. Les G-expression, +ou @dfn{gexps}, consistent en gros en trois formes syntaxiques : +@code{gexp}, @code{ungexp} et @code{ungexp-splicing} (ou plus simplement : +@code{#~}, @code{#$} et @code{#$@@}), qui sont comparable à +@code{quasiquote}, @code{unquote} ett @code{unquote-splicing} respectivement +(@pxref{Expression Syntax, @code{quasiquote},, guile, GNU Guile Reference +Manual}). Cependant il y a des différences majeures : @itemize @item -Gexps are meant to be written to a file and run or manipulated by other -processes. +Les Gexps sont conçues pour être écrites dans un fichier et être lancées ou +manipulées par d'autres processus. @item -When a high-level object such as a package or derivation is unquoted inside -a gexp, the result is as if its output file name had been introduced. +Lorsqu'un objet de haut-niveau comme un paquet ou une dérivation est +unquotée dans une gexp, le résultat est comme si le nom de fichier de son +résultat avait été introduit. @item -Gexps carry information about the packages or derivations they refer to, and -these dependencies are automatically added as inputs to the build processes -that use them. +Les gexps transportent des informatinos sur les paquets ou les dérivations +auxquels elles se réfèrent, et ces dépendances sont automatiquement ajoutées +comme des entrées du processus de construction qui les utilise. @end itemize -@cindex lowering, of high-level objects in gexps -This mechanism is not limited to package and derivation objects: -@dfn{compilers} able to ``lower'' other high-level objects to derivations or -files in the store can be defined, such that these objects can also be -inserted into gexps. For example, a useful type of high-level objects that -can be inserted in a gexp is ``file-like objects'', which make it easy to -add files to the store and to refer to them in derivations and such (see -@code{local-file} and @code{plain-file} below.) +@cindex abaissement, des objets haut-niveau dans les gepxs +Ce mécanisme n'est pas limité aux paquets et aux dérivations : on peut +définir des @dfn{compilateurs} capable « d'abaisser » d'autres objets de +haut-niveau ou des fichiers dans le dépôt, pour que ces objets puissent +aussi être insérés dans des gexps. Par exemple, des objets haut-niveau +utiles qui pourraient être insérées dans une gexp sont les « objets +simili-fichiers », qui rendent facile l'ajout de fichiers dans le dépôt et +les références vers eux dans les dérivations et autres (voir +@code{local-file} et @code{plain-file} ci-dessous). -To illustrate the idea, here is an example of a gexp: +Pour illustrer cette idée, voici un exemple de gexp : @example (define build-exp @@ -5209,27 +5279,28 @@ To illustrate the idea, here is an example of a gexp: "list-files"))) @end example -This gexp can be passed to @code{gexp->derivation}; we obtain a derivation -that builds a directory containing exactly one symlink to -@file{/gnu/store/@dots{}-coreutils-8.22/bin/ls}: +Cette gexp peut être passée à @code{gexp->derivation} ; on obtient une +dérivation qui construit une répertoire contenant exactement un lien +symbolique à @file{/gnu/store/@dots{}-coreutils-8.22/bin/ls} : @example (gexp->derivation "the-thing" build-exp) @end example -As one would expect, the @code{"/gnu/store/@dots{}-coreutils-8.22"} string -is substituted to the reference to the @var{coreutils} package in the actual -build code, and @var{coreutils} is automatically made an input to the -derivation. Likewise, @code{#$output} (equivalent to @code{(ungexp -output)}) is replaced by a string containing the directory name of the -output of the derivation. +Comme on pourrait s'y attendre, la chaîne +@code{"/gnu/store/@dots{}-coreutils-8.22"} est substituée à la place de la +référence au paquet @var{coreutils} dans le code de construction final, et +@var{coreutils} est automatiquement devenu une entrée de la dérivation. De +même, @code{#$output} (équivalent à @code{(ungexp output)}) est remplacé par +une chaîne de caractères contenant le nom du répertoire de la sortie de la +dérivation. -@cindex cross compilation -In a cross-compilation context, it is useful to distinguish between -references to the @emph{native} build of a package---that can run on the -host---versus references to cross builds of a package. To that end, the -@code{#+} plays the same role as @code{#$}, but is a reference to a native -package build: +@cindex compilation croisée +Dans le contexte d'une compilation croisée, il est utile de distinguer entre +des références à la construction @emph{native} d'un paquet — qui peut être +lancé par l'hôte — et des références à la construction croisée d'un paquet. +Pour cela, @code{#+} joue le même rôle que @code{#$}, mais référence une +construction native d'un paquet : @example (gexp->derivation "vi" @@ -5243,16 +5314,17 @@ package build: @end example @noindent -In the example above, the native build of @var{coreutils} is used, so that -@command{ln} can actually run on the host; but then the cross-compiled build -of @var{emacs} is referenced. +Dans l'exemple ci-dessus, la construction native de @var{coreutils} est +utilisée, pour que @command{ln} puisse effectivement être lancé sur l'hôte ; +mais ensuite la construction croisée d'@var{emacs} est utilisée. -@cindex imported modules, for gexps +@cindex modules importés, pour les gexps @findex with-imported-modules -Another gexp feature is @dfn{imported modules}: sometimes you want to be -able to use certain Guile modules from the ``host environment'' in the gexp, -so those modules should be imported in the ``build environment''. The -@code{with-imported-modules} form allows you to express that: +Une autre fonctionnalité, ce sont les @dfn{modules importés} : parfois vous +voudriez pouvoir utiliser certains modules Guile de « l'environnement hôte » +dans la gexp, donc ces modules devraient être importés dans « +l'environnement de construction ». La forme @code{with-imported-modules} +vous permet d'exprimer ça : @example (let ((build (with-imported-modules '((guix build utils)) @@ -5267,21 +5339,21 @@ so those modules should be imported in the ``build environment''. The @end example @noindent -In this example, the @code{(guix build utils)} module is automatically -pulled into the isolated build environment of our gexp, such that -@code{(use-modules (guix build utils))} works as expected. +Dans cet exemple, le module @code{(guix build utils)} est automatiquement +récupéré dans l'environnement de construction isolé de notre gexp, pour que +@code{(use-modules (guix build utils))} fonctionne comme on s'y attendrait. -@cindex module closure +@cindex closure de module @findex source-module-closure -Usually you want the @emph{closure} of the module to be imported---i.e., the -module itself and all the modules it depends on---rather than just the -module; failing to do that, attempts to use the module will fail because of -missing dependent modules. The @code{source-module-closure} procedure -computes the closure of a module by looking at its source file headers, -which comes in handy in this case: +Typiquement, vous voudriez que la @emph{closure} complète du mondule soit +importé — c.-à-d.@: le module lui-même et tous les modules dont il dépend — +plutôt que seulement le module ; sinon, une tentative de chargement du +module échouera à cause des modules dépendants manquants. La procédure +@code{source-module-closure} calcule la closure d'un module en cherchant +dans ses en-têtes sources, ce qui est pratique dans ce cas : @example -(use-modules (guix modules)) ;for 'source-module-closure' +(use-modules (guix modules)) ;pour 'source-module-closure' (with-imported-modules (source-module-closure '((guix build utils) @@ -5293,15 +5365,16 @@ which comes in handy in this case: @dots{}))) @end example -@cindex extensions, for gexps +@cindex extensions, des gexps @findex with-extensions -In the same vein, sometimes you want to import not just pure-Scheme modules, -but also ``extensions'' such as Guile bindings to C libraries or other -``full-blown'' packages. Say you need the @code{guile-json} package -available on the build side, here's how you would do it: +Dans la même idée, parfois vous pouvez souhaiter importer non seulement des +modules en Scheme pur, mais aussi des « extensions » comme des liaisons +Guile de bibliothèques C ou d'autres paquet « complets ». Disons que vous +voulez utiliser le paquet @code{guile-json} du côté de la construction, +voici comme procéder : @example -(use-modules (gnu packages guile)) ;for 'guile-json' +(use-modules (gnu packages guile)) ;pour 'guile-json' (with-extensions (list guile-json) (gexp->derivation "something-with-json" @@ -5310,72 +5383,73 @@ available on the build side, here's how you would do it: @dots{}))) @end example -The syntactic form to construct gexps is summarized below. +La forme syntaxique pour construire des gexps est résumée ci-dessous. -@deffn {Scheme Syntax} #~@var{exp} -@deffnx {Scheme Syntax} (gexp @var{exp}) -Return a G-expression containing @var{exp}. @var{exp} may contain one or -more of the following forms: +@deffn {Syntaxe Scheme} #~@var{exp} +@deffnx {Syntaxe Scheme} (gexp @var{exp}) +Renvoie une G-expression contenant @var{exp}. @var{exp} peut contenir une +ou plusieurs de ces formes : @table @code @item #$@var{obj} @itemx (ungexp @var{obj}) -Introduce a reference to @var{obj}. @var{obj} may have one of the supported -types, for example a package or a derivation, in which case the -@code{ungexp} form is replaced by its output file name---e.g., +Introduit une référence à @var{obj}. @var{obj} peut être d'un des types +supportés, par exemple un paquet ou une dérivation, auquel cas la forme +@code{ungexp} est remplacée par le nom de fichier de sa sortie — p.@: ex.@: @code{"/gnu/store/@dots{}-coreutils-8.22}. -If @var{obj} is a list, it is traversed and references to supported objects -are substituted similarly. +Si @var{boj} est une liste, elle est traversée et les références aux objets +supportés sont substitués de manière similaire. -If @var{obj} is another gexp, its contents are inserted and its dependencies -are added to those of the containing gexp. +Si @var{obj} est une autre gexp, son contenu est inséré et ses dépendances +sont ajoutées à celle de la gexp qui l'entoure. -If @var{obj} is another kind of object, it is inserted as is. +Si @var{obj} est un autre type d'objet, il est inséré tel quel. @item #$@var{obj}:@var{output} @itemx (ungexp @var{obj} @var{output}) -This is like the form above, but referring explicitly to the @var{output} of -@var{obj}---this is useful when @var{obj} produces multiple outputs -(@pxref{Des paquets avec plusieurs résultats}). +Cette forme est similaire à la précédente, mais se réfère explicitement à la +sortie @var{output} de l'objet @var{obj} — c'est utile lorsque @var{obj} +produit plusieurs sorties (@pxref{Des paquets avec plusieurs résultats}). @item #+@var{obj} @itemx #+@var{obj}:output @itemx (ungexp-native @var{obj}) @itemx (ungexp-native @var{obj} @var{output}) -Same as @code{ungexp}, but produces a reference to the @emph{native} build -of @var{obj} when used in a cross compilation context. +Comme @code{ungexp}, mais produit une référence à la construction +@emph{native} de @var{obj} lorsqu'elle est utilisée dans une compilation +croisée. @item #$output[:@var{output}] @itemx (ungexp output [@var{output}]) -Insert a reference to derivation output @var{output}, or to the main output -when @var{output} is omitted. +Insère une référence à la sortie @var{output} de la dérivation, ou à la +sortie principale lorsque @var{output} est omis. -This only makes sense for gexps passed to @code{gexp->derivation}. +Cela ne fait du sens que pour les gexps passées à @code{gexp->derivation}. @item #$@@@var{lst} @itemx (ungexp-splicing @var{lst}) -Like the above, but splices the contents of @var{lst} inside the containing -list. +Comme au dessus, mais recolle (@i{splice}) le contenu de @var{lst} dans la +liste qui la contient. @item #+@@@var{lst} @itemx (ungexp-native-splicing @var{lst}) -Like the above, but refers to native builds of the objects listed in -@var{lst}. +Comme au dessus, mais se réfère à la construction native des objets listés +dans @var{lst}. @end table -G-expressions created by @code{gexp} or @code{#~} are run-time objects of -the @code{gexp?} type (see below.) +Les G-expressions crées par @code{gexp} ou @code{#~} sont des objets à +l'exécution du type @code{gexp?} (voir plus bas). @end deffn -@deffn {Scheme Syntax} with-imported-modules @var{modules} @var{body}@dots{} -Mark the gexps defined in @var{body}@dots{} as requiring @var{modules} in -their execution environment. +@deffn {Syntaxe Scheme} with-imported-modules @var{modules} @var{body}@dots{} +Marque les gexps définies dans @var{body}@dots{} comme requérant +@var{modules} dans leur environnement d'exécution. -Each item in @var{modules} can be the name of a module, such as @code{(guix -build utils)}, or it can be a module name, followed by an arrow, followed by -a file-like object: +Chaque élément dans @var{module} peut être le nom d'un module, comme +@code{(guix build utils)} ou le nom d'un module suivi d'une flêche, suivie +d'un objet simili-fichier : @example `((guix build utils) @@ -5385,63 +5459,71 @@ a file-like object: @end example @noindent -In the example above, the first two modules are taken from the search path, -and the last one is created from the given file-like object. +Dans l'exemple au dessus, les deux premiers modules sont récupérés dans le +chemin de recherche, et le dernier est créé à partir d'un objet +simili-fichier. -This form has @emph{lexical} scope: it has an effect on the gexps directly -defined in @var{body}@dots{}, but not on those defined, say, in procedures -called from @var{body}@dots{}. +Cette forme a une portée @emph{lexicale} : elle a un effet sur les gexp +directement définies dans @var{body}@dots{}, mais pas sur celles définies +dans des procédures appelées par @var{body}@dots{}. @end deffn -@deffn {Scheme Syntax} with-extensions @var{extensions} @var{body}@dots{} -Mark the gexps defined in @var{body}@dots{} as requiring @var{extensions} in -their build and execution environment. @var{extensions} is typically a list -of package objects such as those defined in the @code{(gnu packages guile)} -module. +@deffn {Syntaxe Scheme} with-extensions @var{extensions} @var{body}@dots{} +Marque les gexps définies dans @var{body}@dots{} comme requérant +@var{extensions} dans leur environnement de construction et d'exécution. +@var{extensions} est typiquement une liste d'objets paquets comme définis +dans le module @code{(gnu packages guile)}. -Concretely, the packages listed in @var{extensions} are added to the load -path while compiling imported modules in @var{body}@dots{}; they are also -added to the load path of the gexp returned by @var{body}@dots{}. +Concrètement, les paquets listés dans @var{extensions} sont ajoutés au +chemin de chargement lors de la compilation des modules importés dans +@var{body}@dots{} ; ils sont aussi ajoutés au chemin de chargement de la +gexp renvoyée par @var{body}@dots{}. @end deffn -@deffn {Scheme Procedure} gexp? @var{obj} -Return @code{#t} if @var{obj} is a G-expression. +@deffn {Procédure Scheme} gexp? @var{obj} +Renvoie @code{#t} si @var{obj} est une G-expression. @end deffn -G-expressions are meant to be written to disk, either as code building some -derivation, or as plain files in the store. The monadic procedures below -allow you to do that (@pxref{La monad du dépôt}, for more information about -monads.) +Les G-expressions sont conçues pour être écrites sur le disque, soit en tant +que code pour construire une dérivation, soit en tant que fichier normal +dans le dépôt. Les procédure monadiques suivantes vous permettent de faire +cela (@pxref{La monad du dépôt}, pour plus d'information sur les monads). -@deffn {Monadic Procedure} gexp->derivation @var{name} @var{exp} @ - [#:system (%current-system)] [#:target #f] [#:graft? #t] @ [#:hash #f] -[#:hash-algo #f] @ [#:recursive? #f] [#:env-vars '()] [#:modules '()] @ -[#:module-path @var{%load-path}] @ [#:effective-version "2.2"] @ +@deffn {Procédure Monadique} gexp->derivation @var{name} @var{exp} @ + [#:system (%current-system)] [#:target #f] [#:graft? #t] @ +[#:hash #f] [#:hash-algo #f] @ +[#:recursive? #f] [#:env-vars '()] [#:modules '()] @ +[#:module-path @var{%load-path}] @ +[#:effective-version "2.2"] @ [#:references-graphs #f] [#:allowed-references #f] @ -[#:disallowed-references #f] @ [#:leaked-env-vars #f] @ [#:script-name -(string-append @var{name} "-builder")] @ [#:deprecation-warnings #f] @ -[#:local-build? #f] [#:substitutable? #t] [#:guile-for-build #f] Return a -derivation @var{name} that runs @var{exp} (a gexp) with -@var{guile-for-build} (a derivation) on @var{system}; @var{exp} is stored in -a file called @var{script-name}. When @var{target} is true, it is used as -the cross-compilation target triplet for packages referred to by @var{exp}. +[#:disallowed-references #f] @ +[#:leaked-env-vars #f] @ +[#:script-name (string-append @var{name} "-builder")] @ +[#:deprecation-warnings #f] @ +[#:local-build? #f] [#:substitutable? #t] [#:guile-for-build #f] +Renvoie une dérivation @var{name} qui lance @var{exp} (une gexp) avec +@var{guile-for-build} (une dérivation) sur @var{system} ; @var{exp} est +stocké dans un fichier appelé @var{script-name}. Lorsque @var{target} est +vraie, elle est utilisée comme triplet de cible de compilation croisée pour +les paquets référencés par @var{exp}. -@var{modules} is deprecated in favor of @code{with-imported-modules}. Its -meaning is to make @var{modules} available in the evaluation context of -@var{exp}; @var{modules} is a list of names of Guile modules searched in -@var{module-path} to be copied in the store, compiled, and made available in -the load path during the execution of @var{exp}---e.g., @code{((guix build -utils) (guix build gnu-build-system))}. +@var{modules} est devenu obsolète en faveur de +@code{with-imported-modules}. Sa signification est de rendre @var{modules} +disponibles dans le contexte d'évaluation de @var{exp} ; @var{modules} est +une liste de noms de modules Guile qui sont cherchés dans @var{module-path} +pour les copier dans le dépôt, les compiler et les rendre disponibles dans +le chemin de chargement pendant l'exécution de @var{exp} — p.@: ex.@: +@code{((guix build utils) (guix build gnu-build-system))}. -@var{effective-version} determines the string to use when adding extensions -of @var{exp} (see @code{with-extensions}) to the search path---e.g., -@code{"2.2"}. +@var{effective-version} détermine la chaîne à utiliser lors d'ajout +d'extensions de @var{exp} (voir @code{with-extensions}) au chemin de +recherche — p.@: ex.@: @code{"2.2"}. -@var{graft?} determines whether packages referred to by @var{exp} should be -grafted when applicable. +@var{graft?} détermine si les paquets référencés par @var{exp} devraient +être greffés si possible. -When @var{references-graphs} is true, it must be a list of tuples of one of -the following forms: +Lorsque @var{references-graphs} est vrai, il doit s'agir d'une liste de +tuples de la forme suivante : @example (@var{file-name} @var{package}) @@ -5451,85 +5533,92 @@ the following forms: (@var{file-name} @var{store-item}) @end example -The right-hand-side of each element of @var{references-graphs} is -automatically made an input of the build process of @var{exp}. In the build -environment, each @var{file-name} contains the reference graph of the -corresponding item, in a simple text format. +La partie droite des éléments de @var{references-graphs} est automatiquement +transformée en une entrée du processus de construction @var{exp}. Dans +l'environnement de construction, chaque @var{file-name} contient le graphe +des références de l'élément correspondant, dans un format texte simple. -@var{allowed-references} must be either @code{#f} or a list of output names -and packages. In the latter case, the list denotes store items that the -result is allowed to refer to. Any reference to another store item will -lead to a build error. Similarly for @var{disallowed-references}, which can -list items that must not be referenced by the outputs. +@var{allowed-references} doit soit être @code{#f}, soit une liste de noms de +sorties ou de paquets. Dans ce dernier cas, la liste dénote les éléments du +dépôt auxquels le résultat a le droit de faire référence. Toute référence à +un autre élément du dépôt conduira à une erreur à la construction. Comme +pour @var{disallowed-references}, qui peut lister des éléments qui ne +doivent pas être référencés par les sorties. -@var{deprecation-warnings} determines whether to show deprecation warnings -while compiling modules. It can be @code{#f}, @code{#t}, or -@code{'detailed}. +@var{deprecation-warnings} détermine s'il faut afficher les avertissement +d'obsolescence à la compilation de modules. Il peut valoir @code{#f}, +@code{t} ou @code{'detailed}. -The other arguments are as for @code{derivation} (@pxref{Dérivations}). +Les autres arguments sont les mêmes que pour @code{derivation} +(@pxref{Dérivations}). @end deffn -@cindex file-like objects -The @code{local-file}, @code{plain-file}, @code{computed-file}, -@code{program-file}, and @code{scheme-file} procedures below return -@dfn{file-like objects}. That is, when unquoted in a G-expression, these -objects lead to a file in the store. Consider this G-expression: +@cindex objets simili-fichiers +Les procédures @code{local-file}, @code{plain-file}, @code{computed-file}, +@code{program-file} et @code{scheme-file} ci-dessous renvoient des +@dfn{objets simili-fichiers}. C'est-à-dire, lorsqu'ils sont unquotés dans +une G-expression, ces objets donnent un fichier dans le dépôt. Considérez +cette G-expression : @example #~(system* #$(file-append glibc "/sbin/nscd") "-f" #$(local-file "/tmp/my-nscd.conf")) @end example -The effect here is to ``intern'' @file{/tmp/my-nscd.conf} by copying it to -the store. Once expanded, for instance @i{via} @code{gexp->derivation}, the -G-expression refers to that copy under @file{/gnu/store}; thus, modifying or -removing the file in @file{/tmp} does not have any effect on what the -G-expression does. @code{plain-file} can be used similarly; it differs in -that the file content is directly passed as a string. +Ici, l'effet est « d'internaliser » @file{/tmp/my-nscd.conf} en le copiant +dans le dépôt. Une fois étendu, par exemple via @code{gexp->derivation}, la +G-expression se réfère à cette copie dans @file{/gnu/store} ; ainsi, +modifier ou supprimer le fichier dans @file{/tmp} n'a aucun effet sur ce que +fait la G-expression. @code{plain-file} peut être utilisé de la même +manière ; elle est seulement différente par le fait que le contenu du +fichier est passé directement par une chaîne de caractères. -@deffn {Scheme Procedure} local-file @var{file} [@var{name}] @ - [#:recursive? #f] [#:select? (const #t)] Return an object representing local -file @var{file} to add to the store; this object can be used in a gexp. If -@var{file} is a relative file name, it is looked up relative to the source -file where this form appears. @var{file} will be added to the store under -@var{name}--by default the base name of @var{file}. +@deffn {Procédure Scheme} local-file @var{file} [@var{name}] @ + [#:recursive? #f] [#:select? (const #t)] +Renvoie un objet représentant un fichier local @var{file} à ajouter au dépôt +; cet objet peut être utilisé dans une gexp. Si @var{file} est un nom de +fichier relatif, il est récupéré à partir de la position du fichier source +dans lequel il apparaît. @var{file} sera ajouté au dépôt sous le nom +@var{name} — par défaut le nom de base de @var{file}. -When @var{recursive?} is true, the contents of @var{file} are added -recursively; if @var{file} designates a flat file and @var{recursive?} is -true, its contents are added, and its permission bits are kept. +Lorsque @var{recursive?} est vraie, le contenu de @var{file} est ajouté +récursivement ; si @var{file} désigne un fichier simple et que +@var{recursive?} est vrai, son contenu est ajouté et ses bits de permissions +sont préservés. -When @var{recursive?} is true, call @code{(@var{select?} @var{file} -@var{stat})} for each directory entry, where @var{file} is the entry's -absolute file name and @var{stat} is the result of @code{lstat}; exclude -entries for which @var{select?} does not return true. +Lorsque @var{recursive?} est vraie, appelle @code{(@var{select?} @var{file} +@var{stat})} pour chaque répertoire où @var{file} est le nom de fichier +absolu de l'entrée et @var{stat} est le résultat de @code{lstat} ; à +l'exception des entrées pour lesquelles @var{select?} ne renvoie pas vrai. -This is the declarative counterpart of the @code{interned-file} monadic -procedure (@pxref{La monad du dépôt, @code{interned-file}}). +C'est la version déclarative de la procédure monadique @code{interned-file} +(@pxref{La monad du dépôt, @code{interned-file}}). @end deffn -@deffn {Scheme Procedure} plain-file @var{name} @var{content} +@deffn {Procédure Scheme} plain-file @var{name} @var{content} Return an object representing a text file called @var{name} with the given -@var{content} (a string) to be added to the store. +@var{content} (a string or a bytevector) to be added to the store. -This is the declarative counterpart of @code{text-file}. +C'est la version déclarative de @code{text-file}. @end deffn -@deffn {Scheme Procedure} computed-file @var{name} @var{gexp} @ - [#:options '(#:local-build? #t)] Return an object representing the store -item @var{name}, a file or directory computed by @var{gexp}. @var{options} -is a list of additional arguments to pass to @code{gexp->derivation}. +@deffn {Procédure Scheme} computed-file @var{name} @var{gexp} @ + [#:options '(#:local-build? #t)] +Renvoie un objet représentant un élément du dépôt @var{name}, un fichier ou +un répertoire calculé par @var{gexp}. @var{options} est une liste +d'arguments supplémentaires à passer à @code{gexp->derivation}. -This is the declarative counterpart of @code{gexp->derivation}. +C'est la version déclarative de @code{gexp->derivation}. @end deffn -@deffn {Monadic Procedure} gexp->script @var{name} @var{exp} @ - [#:guile (default-guile)] [#:module-path %load-path] Return an executable -script @var{name} that runs @var{exp} using @var{guile}, with @var{exp}'s -imported modules in its search path. Look up @var{exp}'s modules in -@var{module-path}. +@deffn {Procédure monadique} gexp->script @var{name} @var{exp} @ + [#:guile (default-guile)] [#:module-path %load-path] +Renvoie un script exécutable @var{name} qui lance @var{exp} avec +@var{guile}, avec les modules importés de @var{exp} dans son chemin de +recherche. Cherche les modules de @var{exp} dans @var{module-path}. -The example below builds a script that simply invokes the @command{ls} -command: +L'exemple ci-dessous construit un script qui invoque simplement la commande +@command{ls} : @example (use-modules (guix gexp) (gnu packages base)) @@ -5539,9 +5628,9 @@ command: "ls")) @end example -When ``running'' it through the store (@pxref{La monad du dépôt, -@code{run-with-store}}), we obtain a derivation that produces an executable -file @file{/gnu/store/@dots{}-list-files} along these lines: +Lorsqu'elle est « lancée » à travers le dépôt (@pxref{La monad du dépôt, +@code{run-with-store}}), on obtient une dérivation qui produit une fichier +exécutable @file{/gnu/store/@dots{}-list-files} qui ressemble à : @example #!/gnu/store/@dots{}-guile-2.0.11/bin/guile -ds @@ -5550,107 +5639,115 @@ file @file{/gnu/store/@dots{}-list-files} along these lines: @end example @end deffn -@deffn {Scheme Procedure} program-file @var{name} @var{exp} @ - [#:guile #f] [#:module-path %load-path] Return an object representing the -executable store item @var{name} that runs @var{gexp}. @var{guile} is the -Guile package used to execute that script. Imported modules of @var{gexp} -are looked up in @var{module-path}. +@deffn {Procédure Scheme} program-file @var{name} @var{exp} @ + [#:guile #f] [#:module-path %load-path] +Renvoie un objet représentant un élément du dépôt @var{name} qui lance +@var{gexp}. @var{guile} est le paquet Guile à utiliser pour exécuter le +script. Les modules importés par @var{gexp} sont recherchés dans +@var{module-path}. -This is the declarative counterpart of @code{gexp->script}. +C'est la version déclarative de @code{gexp->script}. @end deffn -@deffn {Monadic Procedure} gexp->file @var{name} @var{exp} @ - [#:set-load-path? #t] [#:module-path %load-path] @ [#:splice? #f] @ [#:guile -(default-guile)] Return a derivation that builds a file @var{name} -containing @var{exp}. When @var{splice?} is true, @var{exp} is considered -to be a list of expressions that will be spliced in the resulting file. +@deffn {Procédure monadique} gexp->file @var{name} @var{exp} @ + [#:set-load-path? #t] [#:module-path %load-path] @ +[#:splice? #f] @ +[#:guile (default-guile)] +Renvoie une dérivation qui construit un fichier @var{name} contenant +@var{exp}. Lorsque @var{splice?} est vrai, @var{exp} est considéré comme +une liste d'expressions qui seront splicée dans le fichier qui en résulte. -When @var{set-load-path?} is true, emit code in the resulting file to set -@code{%load-path} and @code{%load-compiled-path} to honor @var{exp}'s -imported modules. Look up @var{exp}'s modules in @var{module-path}. +Lorsque @var{set-load-path?} est vrai, émet du code dans le fichier de +résultat pour initialiser @code{%load-path} et @code{%load-compiled-path} +pour honorer les modules importés de @var{exp}. Les modules de @var{exp} +sont trouvés dans @var{module-path}. -The resulting file holds references to all the dependencies of @var{exp} or -a subset thereof. +Le fichier qui en résulte retient les références à toutes les dépendances de +@var{exp} ou un sous-ensemble. @end deffn -@deffn {Scheme Procedure} derivation @var{store} @var{name} @var{builder} @ -Return an object representing the Scheme file @var{name} that contains +@deffn {Procédure Scheme} scheme-file @var{name} @var{exp} [#:splice? #f] +Renvoie un objet représentant le fichier Scheme @var{name} qui contient @var{exp}. -This is the declarative counterpart of @code{gexp->file}. +C'est la version déclarative de @code{gexp->file}. @end deffn -@deffn {Monadic Procedure} text-file* @var{name} @var{text} @dots{} -Return as a monadic value a derivation that builds a text file containing -all of @var{text}. @var{text} may list, in addition to strings, objects of -any type that can be used in a gexp: packages, derivations, local file -objects, etc. The resulting store file holds references to all these. +@deffn {Procédure monadique} text-file* @var{name} @var{text} @dots{} +Renvoie une valeur monadique qui construit un ficher texte contenant +@var{text}. @var{text} peut lister, en plus de chaînes de caractères, des +objet de n'importe quel type qui peut être utilisé dans une gexp : des +paquets, des dérivations, des fichiers objet locaux, etc. Le fichier du +dépôt qui en résulte en retient toutes les références. -This variant should be preferred over @code{text-file} anytime the file to -create will reference items from the store. This is typically the case when -building a configuration file that embeds store file names, like this: +Cette variante devrait être préférée à @code{text-file} lorsque vous +souhaitez créer des fichiers qui référencent le dépôt. Cela est le cas +typiquement lorsque vous construisez un fichier de configuration qui +contient des noms de fichiers du dépôt, comme ceci : @example (define (profile.sh) - ;; Return the name of a shell script in the store that - ;; initializes the 'PATH' environment variable. + ;; Renvoie le nom d'un script shell dans le dépôt qui initialise + ;; la variable d'environnement « PATH ». (text-file* "profile.sh" "export PATH=" coreutils "/bin:" grep "/bin:" sed "/bin\n")) @end example -In this example, the resulting @file{/gnu/store/@dots{}-profile.sh} file -will reference @var{coreutils}, @var{grep}, and @var{sed}, thereby -preventing them from being garbage-collected during its lifetime. +Dans cet exemple, le fichier @file{/gnu/store/@dots{}-profile.sh} qui en +résulte référence @var{coreutils}, @var{grep} et @var{sed}, ce qui les +empêche d'être glanés tant que le script est accessible. @end deffn -@deffn {Scheme Procedure} mixed-text-file @var{name} @var{text} @dots{} -Return an object representing store file @var{name} containing @var{text}. -@var{text} is a sequence of strings and file-like objects, as in: +@deffn {Procédure Scheme} mixed-text-file @var{name} @var{text} @dots{} +Renvoie un objet représentant le fichier du dépôt @var{name} contenant +@var{text}. @var{text} est une séquence de chaînes de caractères et de +fichiers simili-objets, comme dans : @example (mixed-text-file "profile" "export PATH=" coreutils "/bin:" grep "/bin") @end example -This is the declarative counterpart of @code{text-file*}. +C'est la version déclarative de @code{text-file*}. @end deffn -@deffn {Scheme Procedure} file-union @var{name} @var{files} -Return a @code{} that builds a directory containing all of -@var{files}. Each item in @var{files} must be a two-element list where the -first element is the file name to use in the new directory, and the second -element is a gexp denoting the target file. Here's an example: +@deffn {Procédure Scheme} file-union @var{name} @var{files} +Renvoie un @code{} qui construit un répertoire qui contient +tous les fichiers de @var{files}. Chaque élément de @var{files} doit être +une paire où le premier élément est le nom de fichier à utiliser dans le +nouveau répertoire et le second élément est une gexp dénotant le fichier +cible. Voici un exemple : @example (file-union "etc" `(("hosts" ,(plain-file "hosts" "127.0.0.1 localhost")) ("bashrc" ,(plain-file "bashrc" - "alias ls='ls --color'")))) + "alias ls='ls --color=auto'")))) @end example -This yields an @code{etc} directory containing these two files. +Cela crée un répertoire @code{etc} contenant ces deux fichiers. @end deffn -@deffn {Scheme Procedure} directory-union @var{name} @var{things} -Return a directory that is the union of @var{things}, where @var{things} is -a list of file-like objects denoting directories. For example: +@deffn {Procédure Scheme} directory-union @var{name} @var{things} +Renvoie un répertoire qui est l'union de @var{things}, où @var{things} est +une liste d'objets simili-fichiers qui dénotent des répertoires. Par exemple +: @example (directory-union "guile+emacs" (list guile emacs)) @end example -yields a directory that is the union of the @code{guile} and @code{emacs} -packages. +crée un répertoire qui est l'union des paquets @code{guile} et @code{emacs}. @end deffn -@deffn {Scheme Procedure} file-append @var{obj} @var{suffix} @dots{} -Return a file-like object that expands to the concatenation of @var{obj} and -@var{suffix}, where @var{obj} is a lowerable object and each @var{suffix} is -a string. +@deffn {Procédure Scheme} file-append @var{obj} @var{suffix} @dots{} +Renvoie un objet simili-fichier qui correspond à la concaténation de +@var{obj} et @var{suffix} où @var{obj} est un objet abaissable et chaque +@var{suffix} est une chaîne de caractères. -As an example, consider this gexp: +Par exemple, considérez cette gexp : @example (gexp->script "run-uname" @@ -5658,7 +5755,7 @@ As an example, consider this gexp: "/bin/uname"))) @end example -The same effect could be achieved with: +On peut obtenir le même effet avec : @example (gexp->script "run-uname" @@ -5666,31 +5763,87 @@ The same effect could be achieved with: "/bin/uname"))) @end example -There is one difference though: in the @code{file-append} case, the -resulting script contains the absolute file name as a string, whereas in the -second case, the resulting script contains a @code{(string-append @dots{})} -expression to construct the file name @emph{at run time}. +Il y a une différence cependant : dans le cas @code{file-append}, le script +qui en résulte contient le nom de fichier absolu comme une chaîne de +caractère alors que dans le deuxième cas, le script contient une expression +@code{(string-append @dots{})} pour construire le nom de fichier @emph{à +l'exécution}. @end deffn -Of course, in addition to gexps embedded in ``host'' code, there are also -modules containing build tools. To make it clear that they are meant to be -used in the build stratum, these modules are kept in the @code{(guix build -@dots{})} name space. +Bien sûr, en plus de gexps inclues dans le code « hôte », certains modules +contiennent des outils de construction. Pour savoir facilement qu'ils sont +à utiliser dans la strate de construction, ces modules sont gardés dans +l'espace de nom @code{(guix build @dots{})}. -@cindex lowering, of high-level objects in gexps -Internally, high-level objects are @dfn{lowered}, using their compiler, to -either derivations or store items. For instance, lowering a package yields -a derivation, and lowering a @code{plain-file} yields a store item. This is -achieved using the @code{lower-object} monadic procedure. +@cindex abaissement, des objets haut-niveau dans les gepxs +En interne, les objets de haut-niveau sont @dfn{abaissés}, avec leur +compilateur, soit en des dérivations, soit en des objets du dépôt. Par +exemple, abaisser un paquet crée une dérivation, et abaisser un +@code{plain-file} crée un élément du dépôt. Cela est effectué par la +procédure monadique @code{lower-object}. -@deffn {Monadic Procedure} lower-object @var{obj} [@var{system}] @ - [#:target #f] Return as a value in @var{%store-monad} the derivation or -store item corresponding to @var{obj} for @var{system}, cross-compiling for -@var{target} if @var{target} is true. @var{obj} must be an object that has -an associated gexp compiler, such as a @code{}. +@deffn {Procédure Monadique} lower-object @var{obj} [@var{system}] @ + [#:target #f] +Renvoie la dérivation ou l'élément du dépôt comme une valeur de +@var{%store-monad} qui correspond à @var{obj} pour @var{system}, en +compilant de manière croisée pour @var{target} si @var{target} est vrai. +@var{obj} doit être un objet qui a un compilateur de gexp associé, comme un +@code{}. @end deffn +@node Invoking guix repl +@section Invoking @command{guix repl} + +@cindex REPL, read-eval-print loop +The @command{guix repl} command spawns a Guile @dfn{read-eval-print loop} +(REPL) for interactive programming (@pxref{Using Guile Interactively,,, +guile, GNU Guile Reference Manual}). Compared to just launching the +@command{guile} command, @command{guix repl} guarantees that all the Guix +modules and all its dependencies are available in the search path. You can +use it this way: + +@example +$ guix repl +scheme@@(guile-user)> ,use (gnu packages base) +scheme@@(guile-user)> coreutils +$1 = # +@end example + +@cindex inferiors +In addition, @command{guix repl} implements a simple machine-readable REPL +protocol for use by @code{(guix inferior)}, a facility to interact with +@dfn{inferiors}, separate processes running a potentially different revision +of Guix. + +The available options are as follows: + +@table @code +@item --type=@var{type} +@itemx -t @var{type} +Start a REPL of the given @var{TYPE}, which can be one of the following: + +@table @code +@item guile +This is default, and it spawns a standard full-featured Guile REPL. +@item machine +Spawn a REPL that uses the machine-readable protocol. This is the protocol +that the @code{(guix inferior)} module speaks. +@end table + +@item --listen=@var{extrémité} +By default, @command{guix repl} reads from standard input and writes to +standard output. When this option is passed, it will instead listen for +connections on @var{endpoint}. Here are examples of valid options: + +@table @code +@item --listen=tcp:37146 +Accept connections on localhost on port 37146. + +@item --listen=unix:/tmp/socket +Accept connections on the Unix-domain socket @file{/tmp/socket}. +@end table +@end table @c ********************************************************************* @node Utilitaires @@ -5728,11 +5881,11 @@ Guix d'une manière pratique. @cindex construction de paquets @cindex @command{guix build} -The @command{guix build} command builds packages or derivations and their -dependencies, and prints the resulting store paths. Note that it does not -modify the user's profile---this is the job of the @command{guix package} -command (@pxref{Invoquer guix package}). Thus, it is mainly useful for -distribution developers. +La commande @command{guix build} construit des paquets ou des dérivations et +leurs dépendances et affiche les chemins du dépôt qui en résulte. Remarquez +qu'elle ne modifie pas le profil de l'utilisateur — c'est le travail de la +commande @command{guix package} (@pxref{Invoquer guix package}). Ainsi, +elle est surtout utile pour les développeurs de la distribution. La syntaxe générale est : @@ -5740,34 +5893,34 @@ La syntaxe générale est : guix build @var{options} @var{package-or-derivation}@dots{} @end example -As an example, the following command builds the latest versions of Emacs and -of Guile, displays their build logs, and finally displays the resulting -directories: +Par exemple, la commande suivante construit la dernière version d'Emacs et +de Guile, affiche leur journaux de construction et enfin affiche les +répertoires des résultats : @example guix build emacs guile @end example -Similarly, the following command builds all the available packages: +De même, la commande suivante construit tous les paquets disponibles : @example guix build --quiet --keep-going \ `guix package -A | cut -f1,2 --output-delimiter=@@` @end example -@var{package-or-derivation} may be either the name of a package found in the -software distribution such as @code{coreutils} or @code{coreutils@@8.20}, or -a derivation such as @file{/gnu/store/@dots{}-coreutils-8.19.drv}. In the -former case, a package with the corresponding name (and optionally version) -is searched for among the GNU distribution modules (@pxref{Modules de paquets}). +@var{package-or-derivation} peut être soit le nom d'un paquet trouvé dans la +distribution logicielle comme @code{coreutils}, soit @code{coreutils@@8.20}, +soit une dérivation comme @file{/gnu/store/@dots{}-coreutils-8.19.drv}. +Dans le premier cas, la commande cherchera un paquet avec le nom +correspondant (et éventuellement la version) dans les modules de la +distribution GNU (@pxref{Modules de paquets}). -Alternatively, the @code{--expression} option may be used to specify a -Scheme expression that evaluates to a package; this is useful when -disambiguating among several same-named packages or package variants is -needed. +Autrement, l'option @code{--expression} peut être utilisée pour spécifier +une expression Scheme qui s'évalue en un paquet ; c'est utile pour +différencier des paquets avec le même nom ou des variantes de paquets. -There may be zero or more @var{options}. The available options are -described in the subsections below. +Il peut y avoir aucune, une ou plusieurs @var{options}. Les options +disponibles sont décrites dans les sous-sections ci-dessous. @menu * Options de construction communes:: Options de construction pour la @@ -5781,56 +5934,60 @@ described in the subsections below. @node Options de construction communes @subsection Options de construction communes -A number of options that control the build process are common to -@command{guix build} and other commands that can spawn builds, such as -@command{guix package} or @command{guix archive}. These are the following: +Un certain nombre d'options qui contrôlent le processus de construction sont +communes avec @command{guix build} et les autres commandes qui peuvent +générer des constructions, comme @command{guix package} ou @command{guix +archive}. Voici ces options : @table @code -@item --load-path=@var{directory} -@itemx -L @var{directory} -Add @var{directory} to the front of the package module search path +@item --load-path=@var{répertoire} +@itemx -L @var{répertoire} +Ajoute @var{répertoire} au début du chemin de recherche de module de paquets (@pxref{Modules de paquets}). -This allows users to define their own packages and make them visible to the -command-line tools. +Cela permet à des utilisateurs de définir leur propres paquets et les rendre +disponibles aux outils en ligne de commande. @item --keep-failed @itemx -K -Keep the build tree of failed builds. Thus, if a build fails, its build -tree is kept under @file{/tmp}, in a directory whose name is shown at the -end of the build log. This is useful when debugging build issues. -@xref{Débogage des échecs de construction}, for tips and tricks on how to debug build -issues. +Garde l'arborescence de construction des constructions en échec. Ainsi, si +une construction échoue, son arborescence de construction est préservée dans +@file{/tmp}, dans un répertoire dont le nom est affiché à la fin du journal +de construction. Cela est utile pour déboguer des échecs de construction. +@xref{Débogage des échecs de construction}, pour des astuces sur la manière de déboguer +des problèmes de construction. @item --keep-going @itemx -k -Keep going when some of the derivations fail to build; return only once all -the builds have either completed or failed. +Continue lorsque certaines dérivations échouent ; ne s'arrête que lorsque +toutes les constructions ont soit réussies, soit échouées. -The default behavior is to stop as soon as one of the specified derivations -has failed. +Le comportement par défaut est de s'arrêter dès qu'une des dérivations +spécifiées échoue. @item --dry-run @itemx -n -Do not build the derivations. +Ne pas construire les dérivations. -@anchor{fallback-option} +@anchor{option de repli} @item --fallback -When substituting a pre-built binary fails, fall back to building packages -locally (@pxref{Échec de substitution}). +Lorsque la substitution d'un binaire pré-compilé échoue, construit les +paquets localement à la place (@pxref{Échec de substitution}). @item --substitute-urls=@var{urls} @anchor{client-substitute-urls} -Consider @var{urls} the whitespace-separated list of substitute source URLs, -overriding the default list of URLs of @command{guix-daemon} -(@pxref{daemon-substitute-urls,, @command{guix-daemon} URLs}). +Considère @var{urls} comme une liste d'URL de sources de substituts séparés +par des espaces, et remplace la liste par défaut d'URL de +@command{guix-daemon} (@pxref{daemon-substitute-urls,, @command{guix-daemon} +URLs}). Cela signifie que les substituts peuvent être téléchargés depuis @var{urls}, tant qu'ils sont signés par une clef autorisée par l'administrateur système (@pxref{Substituts}). -When @var{urls} is the empty string, substitutes are effectively disabled. +Lorsque @var{urls} est la chaîne vide, cela a pour effet de désactiver la +substitution. @item --no-substitutes Ne pas utiliser de substitut pour les résultats de la construction. @@ -5838,202 +5995,208 @@ C'est-à-dire, toujours construire localement plutôt que de permettre le téléchargement de binaires pré-construits (@pxref{Substituts}). @item --no-grafts -Do not ``graft'' packages. In practice, this means that package updates -available as grafts are not applied. @xref{Mises à jour de sécurité}, for more -information on grafts. +Ne par « greffer » les paquets. En pratique, cela signifie que les mises à +jour des paquets disponibles comme des greffes ne sont pas appliquées. +@xref{Mises à jour de sécurité}, pour plus d'information sur les greffes. @item --rounds=@var{n} -Build each derivation @var{n} times in a row, and raise an error if -consecutive build results are not bit-for-bit identical. +Construit chaque dérivation @var{n} fois d'affilé, et renvoie une erreur si +les constructions consécutives ne sont pas identiques bit-à-bit. -This is a useful way to detect non-deterministic builds processes. -Non-deterministic build processes are a problem because they make it -practically impossible for users to @emph{verify} whether third-party -binaries are genuine. @xref{Invoquer guix challenge}, for more. +Cela est une manière utile pour détecter des processus de construction non +déterministes. Les processus de construction non déterministes sont +problématiques car ils rendent pratiquement impossible la +@emph{vérification} par les utilisateurs de l'authenticité de binaires +tiers. @xref{Invoquer guix challenge}, pour plus d'informations. -Note that, currently, the differing build results are not kept around, so -you will have to manually investigate in case of an error---e.g., by -stashing one of the build results with @code{guix archive --export} -(@pxref{Invoquer guix archive}), then rebuilding, and finally comparing the -two results. +Remarquez que, les résultats qui diffèrent ne sont pas gardés, donc vous +devrez inspecter manuellement chaque erreur — p.@: ex.@: en gardant l'un des +résultats avec @code{guix archive --export} (@pxref{Invoquer guix archive}), +puis en reconstruisant, et enfin en comparant les deux résultats. @item --no-build-hook -Do not attempt to offload builds @i{via} the ``build hook'' of the daemon -(@pxref{Réglages du délestage du démon}). That is, always build things locally -instead of offloading builds to remote machines. +N'essaye pas de décharger les constructions via le « crochet de construction +» du démon (@pxref{Réglages du délestage du démon}). C'est-à-dire que tout sera +construit localement plutôt que de décharger les constructions à une machine +distante. @item --max-silent-time=@var{secondes} Lorsque le processus de construction ou de substitution restent silencieux pendant plus de @var{secondes}, le terminer et rapporter une erreur de construction. -By default, the daemon's setting is honored (@pxref{Invoquer guix-daemon, -@code{--max-silent-time}}). +Par défaut, les paramètres du démon sont pris en compte (@pxref{Invoquer guix-daemon, @code{--max-silent-time}}). @item --timeout=@var{secondes} De même, lorsque le processus de construction ou de substitution dure plus de @var{secondes}, le terminer et rapporter une erreur de construction. -By default, the daemon's setting is honored (@pxref{Invoquer guix-daemon, -@code{--timeout}}). +Par défaut, les paramètres du démon sont pris en compte (@pxref{Invoquer guix-daemon, @code{--timeout}}). @item --verbosity=@var{level} -Use the given verbosity level. @var{level} must be an integer between 0 and -5; higher means more verbose output. Setting a level of 4 or more may be -helpful when debugging setup issues with the build daemon. +Utilise le niveau de verbosité donné. @var{level} doit être un entier entre +0 et 5 ; les entiers les plus hauts signifient une sortie plus verbeuse. Le +mettre à 4 ou plus peut être utile pour déboguer des problèmes de +configuration du démon de construction. @item --cores=@var{n} @itemx -c @var{n} -Allow the use of up to @var{n} CPU cores for the build. The special value -@code{0} means to use as many CPU cores as available. +Permet d'utiliser jusqu'à @var{n} cœurs du CPU pour la construction. La +valeur spéciale @code{0} signifie autant de cœurs que possible. @item --max-jobs=@var{n} @itemx -M @var{n} -Allow at most @var{n} build jobs in parallel. @xref{Invoquer guix-daemon, -@code{--max-jobs}}, for details about this option and the equivalent -@command{guix-daemon} option. +Permet au plus @var{n} travaux de construction en parallèle. @xref{Invoquer guix-daemon, @code{--max-jobs}}, pour plus de détails sur cette option et +l'option équivalente pour @command{guix-daemon}. @end table -Behind the scenes, @command{guix build} is essentially an interface to the -@code{package-derivation} procedure of the @code{(guix packages)} module, -and to the @code{build-derivations} procedure of the @code{(guix -derivations)} module. +Sous le capot, @command{guix build} est surtout un interface à la procédure +@code{package-derivation} du module @code{(guix packages)}, et à la +procédure @code{build-derivations} du module @code{(guix derivations)}. -In addition to options explicitly passed on the command line, @command{guix -build} and other @command{guix} commands that support building honor the -@code{GUIX_BUILD_OPTIONS} environment variable. +En plus des options passées explicitement par la ligne de commande, +@command{guix build} et les autres commande @command{guix} qui peuvent +effectuer des construction honorent la variable d'environnement +@code{GUIX_BUILD_OPTIONS}. -@defvr {Environment Variable} GUIX_BUILD_OPTIONS -Users can define this variable to a list of command line options that will -automatically be used by @command{guix build} and other @command{guix} -commands that can perform builds, as in the example below: +@defvr {Variable d'environnement} GUIX_BUILD_OPTIONS +Les utilisateurs peuvent définir cette variable à une liste d'options de la +ligne de commande qui seront automatiquement utilisées par @command{guix +build} et les autres commandes @command{guix} qui peuvent effectuer des +constructions, comme dans l'exemple suivant : @example $ export GUIX_BUILD_OPTIONS="--no-substitutes -c 2 -L /foo/bar" @end example -These options are parsed independently, and the result is appended to the -parsed command-line options. +Ces options sont analysées indépendamment, et le résultat est ajouté aux +options de la ligne de commande analysées. @end defvr @node Options de transformation de paquets @subsection Options de transformation de paquets -@cindex package variants -Another set of command-line options supported by @command{guix build} and -also @command{guix package} are @dfn{package transformation options}. These -are options that make it possible to define @dfn{package variants}---for -instance, packages built from different source code. This is a convenient -way to create customized packages on the fly without having to type in the -definitions of package variants (@pxref{Définition des paquets}). +@cindex variantes de paquets +Un autre ensemble d'options de la ligne de commande supportés par +@command{guix build} et aussi @command{guix package} sont les @dfn{options +de transformation de paquets}. Ce sont des options qui rendent possible la +définition de @dfn{variantes de paquets} — par exemple, des paquets +construit à partir de sources différentes. C'est une manière simple de +créer des paquets personnalisés à la volée sans avoir à taper les +définitions de variantes de paquets (@pxref{Définition des paquets}). @table @code @item --with-source=@var{source} -@itemx --with-source=@var{package}=@var{source} -@itemx --with-source=@var{package}@@@var{version}=@var{source} -Use @var{source} as the source of @var{package}, and @var{version} as its -version number. @var{source} must be a file name or a URL, as for -@command{guix download} (@pxref{Invoquer guix download}). +@itemx --with-source=@var{paquet}=@var{source} +@itemx --with-source=@var{paquet}@@@var{version}=@var{source} +Utiles @var{source} comme la source de @var{paquet}, et @var{version} comme +son numéro de version. @var{source} doit être un nom de fichier ou une URL, +comme pour @command{guix download} (@pxref{Invoquer guix download}). -When @var{package} is omitted, it is taken to be the package name specified -on the command line that matches the base of @var{source}---e.g., if -@var{source} is @code{/src/guile-2.0.10.tar.gz}, the corresponding package -is @code{guile}. +Lorsque @var{paquet} est omis, la commande utilisera le nom de paquet +spécifié par la base de @var{source} — p.@: ex.@: si @var{source} est +@code{/src/guix-2.0.10.tar.gz}, le paquet correspondant est @code{guile}. -Likewise, when @var{version} is omitted, the version string is inferred from -@var{source}; in the previous example, it is @code{2.0.10}. +De même, lorsque @var{version} est omis, la chaîne de version est inférée à +partir de @var{source} ; dans l'exemple précédent, il s'agit de +@code{2.0.10}. -This option allows users to try out versions of packages other than the one -provided by the distribution. The example below downloads -@file{ed-1.7.tar.gz} from a GNU mirror and uses that as the source for the -@code{ed} package: +Cette option permet aux utilisateurs d'essayer des version des paquets +différentes de celles fournies par la distribution. L'exemple ci-dessous +télécharge @file{ed-1.7.tar.g} depuis un mirroir GNU et l'utilise comme +source pour le paquet @code{ed} : @example guix build ed --with-source=mirror://gnu/ed/ed-1.7.tar.gz @end example -As a developer, @code{--with-source} makes it easy to test release -candidates: +En tant que développeur, @code{--with-source} permet de tester facilement +des version bêta : @example guix build guile --with-source=../guile-2.0.9.219-e1bb7.tar.xz @end example -@dots{} or to build from a checkout in a pristine environment: +@dots{} ou pour construire un dépôt de gestion de version dans un +environnement vierge : @example $ git clone git://git.sv.gnu.org/guix.git $ guix build guix --with-source=guix@@1.0=./guix @end example -@item --with-input=@var{package}=@var{replacement} -Replace dependency on @var{package} by a dependency on @var{replacement}. -@var{package} must be a package name, and @var{replacement} must be a -package specification such as @code{guile} or @code{guile@@1.8}. +@item --with-input=@var{paquet}=@var{remplaçant} +Remplace la dépendance sur @var{paquet} par une dépendance à +@var{remplaçant}. @var{paquet} doit être un nom de paquet et +@var{remplaçant} doit être une spécification de paquet comme @code{guile} ou +@code{guile@@1.8}. -For instance, the following command builds Guix, but replaces its dependency -on the current stable version of Guile with a dependency on the legacy -version of Guile, @code{guile@@2.0}: +Par exemple, la commande suivante construit Guix, mais remplace sa +dépendance à la version stable actuelle de Guile par une dépendance à une +ancienne version de Guile, @code{guile@@2.0} : @example guix build --with-input=guile=guile@@2.0 guix @end example -This is a recursive, deep replacement. So in this example, both @code{guix} -and its dependency @code{guile-json} (which also depends on @code{guile}) -get rebuilt against @code{guile@@2.0}. +C'est un remplacement récursif profond. Donc dans cet exemple, à la fois +@code{guix} et ses dépendances @code{guile-json} (qui dépend aussi de +@code{guile}) sont reconstruits avec @code{guile@@2.0}. -This is implemented using the @code{package-input-rewriting} Scheme -procedure (@pxref{Définition des paquets, @code{package-input-rewriting}}). +Cette option est implémentée avec la procédure Scheme +@code{package-input-rewriting} (@pxref{Définition des paquets, +@code{package-input-rewriting}}). -@item --with-graft=@var{package}=@var{replacement} -This is similar to @code{--with-input} but with an important difference: -instead of rebuilding the whole dependency chain, @var{replacement} is built -and then @dfn{grafted} onto the binaries that were initially referring to -@var{package}. @xref{Mises à jour de sécurité}, for more information on grafts. +@item --with-graft=@var{paquet}=@var{remplaçant} +Cette option est similaire à @code{--with-input} mais avec une différence +importante : plutôt que de reconstruire la chaîne de dépendance complète, +@var{remplaçant} est construit puis @dfn{greffé} sur les binaires qui +référençaient initialement @var{paquet}. @xref{Mises à jour de sécurité}, pour plus +d'information sur les greffes. -For example, the command below grafts version 3.5.4 of GnuTLS onto Wget and -all its dependencies, replacing references to the version of GnuTLS they -currently refer to: +Par exemple, la commande ci-dessous greffe la version 3.5.4 de GnuTLS sur +Wget et toutes ses dépendances, en remplaçant les références à la version +actuelle de GnuTLS à laquelle ils se réfèrent actuellement : @example guix build --with-graft=gnutls=gnutls@@3.5.4 wget @end example -This has the advantage of being much faster than rebuilding everything. But -there is a caveat: it works if and only if @var{package} and -@var{replacement} are strictly compatible---for example, if they provide a -library, the application binary interface (ABI) of those libraries must be -compatible. If @var{replacement} is somehow incompatible with -@var{package}, then the resulting package may be unusable. Use with care! +Cela a l'avantage d'être bien plus rapide que de tout reconstruire. Mais il +y a un piège : cela ne fonctionne que si @var{paquet} et @var{remplaçant} +sont strictement compatibles — par exemple, s'ils fournissent une +bibliothèque, l'interface binaire applicative (ABI) de ces bibliothèques +doivent être compatibles. Si @var{remplaçant} est incompatible avec +@var{paquet}, alors le paquet qui en résulte peut devenir inutilisable. À +utilisez avec précaution ! @end table @node Options de construction supplémentaires @subsection Options de construction supplémentaires -The command-line options presented below are specific to @command{guix -build}. +Les options de la ligne de commande ci-dessous sont spécifiques à +@command{guix build}. @table @code @item --quiet @itemx -q -Build quietly, without displaying the build log. Upon completion, the build -log is kept in @file{/var} (or similar) and can always be retrieved using -the @option{--log-file} option. +Construire en silence, sans afficher les journaux de construction. À la +fin, le journal de construction est gardé dans @file{/var} (ou similaire) et +on peut toujours l'y trouver avec l'option @option{--log-file}. -@item --file=@var{file} +@item --file=@var{fichier} @itemx -f @var{fichier} -Build the package or derivation that the code within @var{file} evaluates -to. +Construit le paquet ou la dérivation en lequel le code dans @var{file} +s'évalue. -As an example, @var{file} might contain a package definition like this -(@pxref{Définition des paquets}): +Par exemple, @var{file} peut contenir une définition de paquet comme ceci +(@pxref{Définition des paquets}) : @example @verbatiminclude package-hello.scm @@ -6041,47 +6204,50 @@ As an example, @var{file} might contain a package definition like this @item --expression=@var{expr} @itemx -e @var{expr} -Build the package or derivation @var{expr} evaluates to. +Construit le paquet ou la dérivation en lequel @var{expr} s'évalue. -For example, @var{expr} may be @code{(@@ (gnu packages guile) guile-1.8)}, -which unambiguously designates this specific variant of version 1.8 of -Guile. +Par exemple, @var{expr} peut être @code{(@@ (gnu packages guile) +guile-1.8)}, qui désigne sans ambiguïté cette variante spécifique de la +version 1.8 de Guile. -Alternatively, @var{expr} may be a G-expression, in which case it is used as -a build program passed to @code{gexp->derivation} (@pxref{G-Expressions}). +Autrement, @var{exp} peut être une G-expression, auquel cas elle est +utilisée comme un programme de construction passé à @code{gexp->derivation} +(@pxref{G-Expressions}). -Lastly, @var{expr} may refer to a zero-argument monadic procedure -(@pxref{La monad du dépôt}). The procedure must return a derivation as a -monadic value, which is then passed through @code{run-with-store}. +Enfin, @var{expr} peut se référer à une procédure monadique à au moins un +argument (@pxref{La monad du dépôt}). La procédure doit renvoyer une +dérivation comme une valeur monadique, qui est ensuite lancée à travers +@code{run-with-store}. @item --source @itemx -S -Build the source derivations of the packages, rather than the packages -themselves. +Construit les dérivation source des paquets, plutôt que des paquets +eux-même. -For instance, @code{guix build -S gcc} returns something like -@file{/gnu/store/@dots{}-gcc-4.7.2.tar.bz2}, which is the GCC source -tarball. +Par exemple, @code{guix build -S gcc} renvoie quelque chose comme +@file{/gnu/store/@dots{}-gcc-4.7.2.tar.bz2}, qui est l'archive des sources +de GCC. -The returned source tarball is the result of applying any patches and code -snippets specified in the package @code{origin} (@pxref{Définition des paquets}). +L'archive des sources renvoyée est le résultat de l'application des +correctifs et des extraits de code éventuels spécifiés dans le champ +@code{origin} du paquet (@pxref{Définition des paquets}). @item --sources -Fetch and return the source of @var{package-or-derivation} and all their -dependencies, recursively. This is a handy way to obtain a local copy of -all the source code needed to build @var{packages}, allowing you to -eventually build them even without network access. It is an extension of -the @code{--source} option and can accept one of the following optional -argument values: +Récupère et renvoie la source de @var{package-or-derivation} et toute ses +dépendances, récursivement. C'est pratique pour obtenir une copie locale de +tous les codes sources requis pour construire @var{packages}, ce qui vous +permet de les construire plus tard même sans accès réseau. C'est une +extension de l'option @code{--source} et peut accepter l'un des arguments +facultatifs suivants : @table @code @item package -This value causes the @code{--sources} option to behave in the same way as -the @code{--source} option. +Cette valeur fait que l'option @code{--sources} se comporte comme l'option +@code{--source}. @item all -Build the source derivations of all packages, including any source that -might be listed as @code{inputs}. This is the default value. +Construit les dérivations des sources de tous les paquets, dont les sources +qui pourraient être listées dans @code{inputs}. C'est la valeur par défaut. @example $ guix build --sources tzdata @@ -6091,9 +6257,10 @@ The following derivations will be built: @end example @item transitive -Build the source derivations of all packages, as well of all transitive -inputs to the packages. This can be used e.g. to prefetch package source -for later offline building. +Construit les dérivations des sources de tous les paquets, ainsi que toutes +celles les entrées transitives des paquets. On peut utiliser cette option +pour précharger les sources des paquets pour les construire plus tard hors +ligne par exemple. @example $ guix build --sources=transitive tzdata @@ -6115,30 +6282,33 @@ Tenter de construire pour le @var{système} — p.@: ex.@: @code{i686-linux} — plutôt que pour le type de système de l'hôte de construction. @quotation Remarque -The @code{--system} flag is for @emph{native} compilation and must not be -confused with cross-compilation. See @code{--target} below for information -on cross-compilation. +Le drapeau @code{--system} est utilisé pour une compilation @emph{native} et +ne doit pas être confondu avec une compilation croisée. Voir +@code{--target} ci-dessous pour des informations sur la compilation croisée. @end quotation -An example use of this is on Linux-based systems, which can emulate -different personalities. For instance, passing @code{--system=i686-linux} -on an @code{x86_64-linux} system or @code{--system=armhf-linux} on an -@code{aarch64-linux} system allows you to build packages in a complete -32-bit environment. +Par exemple, passer @code{--system=i686-linux} sur un système +@code{x86_64-linux} ou @code{--system=armhf-linux} sur un système +@code{aarch64-linux} vous permet de construire des paquets dans un +environnement entièrement 32-bits. C'est une exemple d'utilisation de cette +option sur les systèmes Linux, qui peuvent émuler plusieurs personnalités. @quotation Remarque -Building for an @code{armhf-linux} system is unconditionally enabled on -@code{aarch64-linux} machines, although certain aarch64 chipsets do not -allow for this functionality, notably the ThunderX. +La possibilité de construire pour un système @code{armhf-linux} est activé +sans condition sur les machines @code{aarch64-linux}, bien que certaines +puces aarch64 n'en soient pas capables, comme les ThunderX. @end quotation -Similarly, when transparent emulation with QEMU and @code{binfmt_misc} is -enabled (@pxref{Services de virtualisation, @code{qemu-binfmt-service-type}}), -you can build for any system for which a QEMU @code{binfmt_misc} handler is -installed. +De même, lorsque l'émulation transparente avec QEMU et @code{binfnmt_misc} +est activée (@pxref{Services de virtualisation, +@code{qemu-binfmt-service-type}}), vous pouvez construire pour n'importe +quel système pour lequel un gestionnaire QEMU @code{binfmt_misc} est +installé. -Builds for a system other than that of the machine you are using can also be -offloaded to a remote machine of the right architecture. @xref{Réglages du délestage du démon}, for more information on offloading. +Les constructions pour un autre système que celui de la machine que vous +utilisez peuvent aussi être déchargées à une machine distante de la bonne +architecture. @xref{Réglages du délestage du démon}, pour plus d'information sur le +déchargement. @item --target=@var{triplet} @cindex compilation croisée @@ -6146,13 +6316,13 @@ Effectuer une compilation croisée pour @var{triplet} qui doit être un triplet GNU valide, comme @code{"mips64el-linux-gnu"} (@pxref{Specifying target triplets, GNU configuration triplets,, autoconf, Autoconf}). -@anchor{build-check} +@anchor{vérification de la construction} @item --check @cindex déterminisme, vérification @cindex reproductibilité, vérification -Rebuild @var{package-or-derivation}, which are already available in the -store, and raise an error if the build results are not bit-for-bit -identical. +Reconstruit les @var{package-or-derivation}, qui sont déjà disponibles dans +le dépôt et lève une erreur si les résultats des constructions ne sont pas +identiques bit-à-bit. Ce mécanisme vous permet de vérifier si les substituts précédemment installés sont authentiques (@pxref{Substituts}) ou si le résultat de la @@ -6164,36 +6334,40 @@ dans le dépôt sous @file{/gnu/store/@dots{}-check}. Cela rend plus facile l'étude des différences entre les deux résultats. @item --repair -@cindex repairing store items +@cindex réparer les éléments du dépôt @cindex corruption, récupérer de -Attempt to repair the specified store items, if they are corrupt, by -re-downloading or rebuilding them. +Essaye de réparer les éléments du dépôt spécifiés, s'ils sont corrompus, en +les téléchargeant ou en les construisant à nouveau. -This operation is not atomic and thus restricted to @code{root}. +Cette opération n'est pas atomique et donc restreinte à l'utilisateur +@code{root} @item --derivations @itemx -d -Return the derivation paths, not the output paths, of the given packages. +Renvoie les chemins de dérivation, et non les chemins de sortie, des paquets +donnés. -@item --root=@var{file} -@itemx -r @var{file} -@cindex GC roots, adding -@cindex garbage collector roots, adding -Make @var{file} a symlink to the result, and register it as a garbage -collector root. +@item --root=@var{fichier} +@itemx -r @var{fichier} +@cindex racines du GC, ajout +@cindex ajout de racines au ramasse-miettes +Fait de @var{fichier} un lien symbolique vers le résultat, et l'enregistre +en tant que racine du ramasse-miettes. -Consequently, the results of this @command{guix build} invocation are -protected from garbage collection until @var{file} is removed. When that -option is omitted, build results are eligible for garbage collection as soon -as the build completes. @xref{Invoquer guix gc}, for more on GC roots. +En conséquence, les résultats de cette invocation de @command{guix build} +sont protégés du ramasse-miettes jusqu'à ce que @var{fichier} soit +supprimé. Lorsque cette option est omise, les constructions sont +susceptibles d'être glanées. @item --log-file -@cindex build logs, access -Return the build log file names or URLs for the given -@var{package-or-derivation}, or raise an error if build logs are missing. +@cindex journaux de construction, accès +Renvoie les noms des journaux de construction ou les URL des +@var{package-or-derivation} donnés ou lève une erreur si les journaux de +construction sont absents. -This works regardless of how packages or derivations are specified. For -instance, the following invocations are equivalent: +Cela fonctionne indépendamment de la manière dont les paquets ou les +dérivations sont spécifiées. Par exemple, les invocations suivantes sont +équivalentes : @example guix build --log-file `guix build -d guile` @@ -6202,40 +6376,44 @@ guix build --log-file guile guix build --log-file -e '(@@ (gnu packages guile) guile-2.0)' @end example -If a log is unavailable locally, and unless @code{--no-substitutes} is -passed, the command looks for a corresponding log on one of the substitute -servers (as specified with @code{--substitute-urls}.) +Si un journal n'est pas disponible localement, à moins que +@code{--no-substitutes} ne soit passé, la commande cherche un journal +correspondant sur l'un des serveurs de substituts (tels que spécifiés avec +@code{--substitute-urls}.) -So for instance, imagine you want to see the build log of GDB on MIPS, but -you are actually on an @code{x86_64} machine: +Donc par exemple, imaginons que vous souhaitiez voir le journal de +construction de GDB sur MIPS, mais que vous n'avez qu'une machine +@code{x86_64} : @example $ guix build --log-file gdb -s mips64el-linux https://hydra.gnu.org/log/@dots{}-gdb-7.10 @end example -You can freely access a huge library of build logs! +Vous pouvez accéder librement à un vaste bibliothèque de journaux de +construction ! @end table @node Débogage des échecs de construction @subsection Débogage des échecs de construction -@cindex build failures, debugging -When defining a new package (@pxref{Définition des paquets}), you will probably -find yourself spending some time debugging and tweaking the build until it -succeeds. To do that, you need to operate the build commands yourself in an -environment as close as possible to the one the build daemon uses. +@cindex échecs de construction, débogage +Lors de la définition d'un nouveau paquet (@pxref{Définition des paquets}), vous +passerez probablement du temps à déboguer et modifier la construction +jusqu'à ce que ça marche. Pour cela, vous devez effectuer les commandes de +construction vous-même dans un environnement le plus proche possible de +celui qu'utilise le démon de construction. -To that end, the first thing to do is to use the @option{--keep-failed} or -@option{-K} option of @command{guix build}, which will keep the failed build -tree in @file{/tmp} or whatever directory you specified as @code{TMPDIR} -(@pxref{Invoquer guix build, @code{--keep-failed}}). +Pour cela, la première chose à faire est d'utiliser l'option +@option{--keep-failed} ou @option{-K} de @command{guix build}, qui gardera +l'arborescence de construction dans @file{/tmp} ou le répertoire spécifié +par @code{TMPDIR} (@pxref{Invoquer guix build, @code{--keep-failed}}). -From there on, you can @command{cd} to the failed build tree and source the -@file{environment-variables} file, which contains all the environment -variable definitions that were in place when the build failed. So let's say -you're debugging a build failure in package @code{foo}; a typical session -would look like this: +À partir de là, vous pouvez vous déplacer dans l'arborescence de +construction et sourcer le fichier @file{environment-variables}, qui +contient toutes les variables d'environnement qui étaient définies lorsque +la construction a échoué. Disons que vous déboguez un échec de construction +dans le paquet @code{foo} ; une session typique ressemblerait à cela : @example $ guix build foo -K @@ -6245,17 +6423,17 @@ $ source ./environment-variables $ cd foo-1.2 @end example -Now, you can invoke commands as if you were the daemon (almost) and -troubleshoot your build process. +Maintenant, vous pouvez invoquer les commandes comme si vous étiez le démon +(presque) et corriger le processus de construction. -Sometimes it happens that, for example, a package's tests pass when you run -them manually but they fail when the daemon runs them. This can happen -because the daemon runs builds in containers where, unlike in our -environment above, network access is missing, @file{/bin/sh} does not exist, -etc. (@pxref{Réglages de l'environnement de construction}). +Parfois il arrive que, par exemple, les tests d'un paquet réussissent +lorsque vous les lancez manuellement mais échouent quand ils sont lancés par +le démon. Cela peut arriver parce que le démon tourne dans un conteneur où, +contrairement à notre environnement au-dessus, l'accès réseau est +indisponible, @file{/bin/sh} n'existe pas, etc (@pxref{Réglages de l'environnement de construction}). -In such cases, you may need to run inspect the build process from within a -container similar to the one the build daemon creates: +Dans ce cas, vous pourriez avoir besoin de lancer le processus de +construction dans un conteneur similaire à celui que le démon crée : @example $ guix build -K foo @@ -6266,162 +6444,168 @@ $ guix environment --no-grafts -C foo --ad-hoc strace gdb [env]# cd foo-1.2 @end example -Here, @command{guix environment -C} creates a container and spawns a new -shell in it (@pxref{Invoquer guix environment}). The @command{--ad-hoc -strace gdb} part adds the @command{strace} and @command{gdb} commands to the -container, which would may find handy while debugging. The -@option{--no-grafts} option makes sure we get the exact same environment, -with ungrafted packages (@pxref{Mises à jour de sécurité}, for more info on grafts). +Ici, @command{guix environment -C} crée un conteneur et démarre un nouveau +shell dedans (@pxref{Invoquer guix environment}). La partie +@command{--ad-hoc strace gdb} ajoute les commandes @command{strace} et +@command{gdb} dans le conteneur, ce qui pourrait s'avérer utile pour le +débogage. L'option @option{--no-grafts} s'assure qu'on obtient le même +environnement, avec des paquets non greffés (@pxref{Mises à jour de sécurité}, pour +plus d'informations sur les greffes). -To get closer to a container like that used by the build daemon, we can -remove @file{/bin/sh}: +Pour obtenir un conteneur plus proche de ce qui serait utilisé par le démon +de construction, on peut enlever @file{/bin/sh} : @example [env]# rm /bin/sh @end example -(Don't worry, this is harmless: this is all happening in the throw-away -container created by @command{guix environment}.) +Ne vous inquiétez pas, c'est sans danger : tout cela se passe dans un +conteneur jetable créé par @command{guix environment}. -The @command{strace} command is probably not in the search path, but we can -run: +La commande @command{strace} n'est probablement pas dans le chemin de +recherche, mais on peut lancer : @example [env]# $GUIX_ENVIRONMENT/bin/strace -f -o log make check @end example -In this way, not only you will have reproduced the environment variables the -daemon uses, you will also be running the build process in a container -similar to the one the daemon uses. +De cette manière, non seulement vous aurez reproduit les variables +d'environnement utilisées par le démon, mais vous lancerez aussi le +processus de construction dans un conteneur similaire à celui utilisé par le +démon. @node Invoquer guix edit -@section Invoking @command{guix edit} +@section Invoquer @command{guix edit} @cindex @command{guix edit} -@cindex package definition, editing -So many packages, so many source files! The @command{guix edit} command -facilitates the life of users and packagers by pointing their editor at the -source file containing the definition of the specified packages. For -instance: +@cindex définition de paquets, modification +Tant de paquets, tant de fichiers source ! La commande @command{guix edit} +facilite la vie des utilisateurs et des packagers en plaçant leur éditeur +sur le fichier source qui contient la définition des paquets spécifiés. Par +exemple : @example guix edit gcc@@4.9 vim @end example @noindent -launches the program specified in the @code{VISUAL} or in the @code{EDITOR} -environment variable to view the recipe of GCC@tie{}4.9.3 and that of Vim. +lance le programme spécifié dans la variable d'environnement @code{VISUAL} +ou @code{EDITOR} pour visionner la recette de GCC@tie{}4.9.3 et cele de Vim. -If you are using a Guix Git checkout (@pxref{Construire depuis Git}), or have -created your own packages on @code{GUIX_PACKAGE_PATH} (@pxref{Définition des paquets}), you will be able to edit the package recipes. Otherwise, you -will be able to examine the read-only recipes for packages currently in the -store. +Si vous utilisez une copie du dépôt Git de Guix (@pxref{Construire depuis Git}), +ou que vous avez créé vos propres paquets dans @code{GUIX_PACKAGE_PATH} +(@pxref{Définition des paquets}), vous pourrez modifier les recettes des +paquets. Sinon, vous pourrez examiner les recettes en lecture-seule des +paquets actuellement dans le dépôt. @node Invoquer guix download -@section Invoking @command{guix download} +@section Invoquer @command{guix download} @cindex @command{guix download} -@cindex downloading package sources -When writing a package definition, developers typically need to download a -source tarball, compute its SHA256 hash, and write that hash in the package -definition (@pxref{Définition des paquets}). The @command{guix download} tool -helps with this task: it downloads a file from the given URI, adds it to the -store, and prints both its file name in the store and its SHA256 hash. +@cindex télécharger les sources des paquets +En écrivant des définitions de paquets, les développeurs ont généralement +besoin de télécharger une archive des sources, calculer son hash SHA256 et +écrire ce hash dans la définition du paquet (@pxref{Définition des paquets}). +L'outil @command{guix download} aide à cette tâche : il télécharge un +fichier à l'URL donné, l'ajoute au dépôt et affiche à la fois son nom dans +le dépôt et son hash SHA56. -The fact that the downloaded file is added to the store saves bandwidth: -when the developer eventually tries to build the newly defined package with -@command{guix build}, the source tarball will not have to be downloaded -again because it is already in the store. It is also a convenient way to -temporarily stash files, which may be deleted eventually (@pxref{Invoquer guix gc}). +Le fait que le fichier téléchargé soit ajouté au dépôt préserve la bande +passante : losque les développeurs finissent par construire le paquet +nouvellement défini avec @command{guix build}, l'archive des sources n'aura +pas besoin d'être téléchargée de nouveau puisqu'elle se trouvera déjà dans +le dépôt. C'est aussi une manière pratique de garder des fichiers +temporairement, qui pourront ensuite être supprimés (@pxref{Invoquer guix gc}). -The @command{guix download} command supports the same URIs as used in -package definitions. In particular, it supports @code{mirror://} URIs. -@code{https} URIs (HTTP over TLS) are supported @emph{provided} the Guile -bindings for GnuTLS are available in the user's environment; when they are -not available, an error is raised. @xref{Guile Preparations, how to install -the GnuTLS bindings for Guile,, gnutls-guile, GnuTLS-Guile}, for more -information. +La commande @command{guix download} supporte les mêmes URI que celles +utilisées dans les définitions de paquets. En particulier, elle supporte +les URI @code {mirror://}. Les URI @code{http} (HTTP sur TLS) sont +supportées @emph{si} les liaisons Guile de GnuTLS sont disponibles dans +l'environnement de l'utilisateur ; si elle ne sont pas disponibles, une +erreur est renvoyée. @xref{Guile Preparations, how to install the GnuTLS +bindings for Guile,, gnutls-guile, GnuTLS-Guile}, pour plus d'informations. -@command{guix download} verifies HTTPS server certificates by loading the -certificates of X.509 authorities from the directory pointed to by the -@code{SSL_CERT_DIR} environment variable (@pxref{Certificats X.509}), -unless @option{--no-check-certificate} is used. +@command{guix download} vérifie les certificats du serveur HTTPS en +chargeant les autorités de certification X.509 depuis le répertoire vers +lequel pointe la variable d'environnement @code{SSL_CERT_DIR} (@pxref{Certificats X.509}), à moins que @option{--no-check-certificate} ne soit utilisé. -The following options are available: +Les options suivantes sont disponibles : @table @code @item --format=@var{fmt} @itemx -f @var{fmt} -Write the hash in the format specified by @var{fmt}. For more information -on the valid values for @var{fmt}, @pxref{Invoquer guix hash}. +Écrit le hash dans le format spécifié par @var{fmt}. Pour plus +d'informations sur les valeurs valides pour @var{fmt}, @pxref{Invoquer guix hash}. @item --no-check-certificate -Do not validate the X.509 certificates of HTTPS servers. +Ne pas valider les certificats HTTPS des serveurs. -When using this option, you have @emph{absolutely no guarantee} that you are -communicating with the authentic server responsible for the given URL, which -makes you vulnerable to ``man-in-the-middle'' attacks. +Lorsque vous utilisez cette option, vous n'avez @emph{absolument aucune +garanti} que vous communiquez avec le serveur authentique responsable de +l'URL donnée, ce qui vous rend vulnérable à des attaques de « l'homme du +milieu ». -@item --output=@var{file} -@itemx -o @var{file} -Save the downloaded file to @var{file} instead of adding it to the store. +@item --output=@var{fichier} +@itemx -o @var{fichier} +Enregistre le fichier téléchargé dans @var{fichier} plutôt que de l'ajouter +au dépôt. @end table @node Invoquer guix hash -@section Invoking @command{guix hash} +@section Invoquer @command{guix hash} @cindex @command{guix hash} -The @command{guix hash} command computes the SHA256 hash of a file. It is -primarily a convenience tool for anyone contributing to the distribution: it -computes the cryptographic hash of a file, which can be used in the -definition of a package (@pxref{Définition des paquets}). +La commande @command{guix hash} calcul le hash SHA256 d'un fichier. C'est +surtout un outil pour simplifier la vie des contributeurs de la distribution +: il calcul le hash cryptographique d'un fichier, qui peut être utilisé dans +la définition d'un paquet (@pxref{Définition des paquets}). La syntaxe générale est : @example -guix hash @var{option} @var{file} +guix hash @var{option} @var{fichier} @end example -When @var{file} is @code{-} (a hyphen), @command{guix hash} computes the -hash of data read from standard input. @command{guix hash} has the -following options: +Lorsque @var{fichier} est @code{-} (un tiret), @command{guix hash} calcul le +hash des données lues depuis l'entrée standard. @command{guix hash} a les +options suivantes : @table @code @item --format=@var{fmt} @itemx -f @var{fmt} -Write the hash in the format specified by @var{fmt}. +Écrit le hash dans le format spécifié par @var{fmt}. -Supported formats: @code{nix-base32}, @code{base32}, @code{base16} -(@code{hex} and @code{hexadecimal} can be used as well). +Les formats supportés sont : @code{nix-base32}, @code{base32}, @code{base16} +(@code{hex} et @code{hexadecimal} peuvent aussi être utilisés). -If the @option{--format} option is not specified, @command{guix hash} will -output the hash in @code{nix-base32}. This representation is used in the -definitions of packages. +Si l'option @option {--format} n'est pas spécifiée, @command{guix hash} +affichera le hash en @code{nix-base32}. Cette représentation est utilisée +dans les définitions des paquets. @item --recursive @itemx -r -Compute the hash on @var{file} recursively. +Calcule le hash sur @var{fichier} récursivement. @c FIXME: Replace xref above with xref to an ``Archive'' section when @c it exists. -In this case, the hash is computed on an archive containing @var{file}, -including its children if it is a directory. Some of the metadata of -@var{file} is part of the archive; for instance, when @var{file} is a -regular file, the hash is different depending on whether @var{file} is -executable or not. Metadata such as time stamps has no impact on the hash -(@pxref{Invoquer guix archive}). +Dans ce cas, le hash est calculé sur une archive contenant @var{fichier}, +dont ses enfants si c'est un répertoire. Certaines métadonnées de +@var{fichier} fait partie de l'archive ; par exemple lorsque @var{fichier} +est un fichier normal, le hash est différent que le @var{fichier} soit +exécutable ou non. Les métadonnées comme un horodatage n'ont aucun impact +sur le hash (@pxref{Invoquer guix archive}). @item --exclude-vcs @itemx -x -When combined with @option{--recursive}, exclude version control system -directories (@file{.bzr}, @file{.git}, @file{.hg}, etc.) +Lorsqu'elle est combinée à @option{--recursive}, exclut les répertoires de +système de contrôle de version (@file{.bzr}, @file{.git}, @file{.hg}, etc). @vindex git-fetch -As an example, here is how you would compute the hash of a Git checkout, -which is useful when using the @code{git-fetch} method (@pxref{Référence d'origine}): +Par exemple, voici comment calculer le hash d'un dépôt Git, ce qui est utile +avec la méthode @code{git-fetch} (@pxref{Référence d'origine}) : @example $ git clone http://example.org/foo.git @@ -6431,17 +6615,18 @@ $ guix hash -rx . @end table @node Invoquer guix import -@section Invoking @command{guix import} +@section Invoquer @command{guix import} -@cindex importing packages -@cindex package import -@cindex package conversion -@cindex Invoking @command{guix import} -The @command{guix import} command is useful for people who would like to add -a package to the distribution with as little work as possible---a legitimate -demand. The command knows of a few repositories from which it can -``import'' package metadata. The result is a package definition, or a -template thereof, in the format we know (@pxref{Définition des paquets}). +@cindex importer des paquets +@cindex paquets importés +@cindex conversion de paquets +@cindex Invoquer @command{guix import} +La commande @command{guix import} est utile pour les gens qui voudraient +ajouter un paquet à la distribution avec aussi peu de travail que possible — +une demande légitime. La commande connaît quelques dépôts logiciels d'où +elle peut « importer » des métadonnées de paquets. Le résultat est une +définition de paquet, ou un modèle de définition, dans le format reconnu par +Guix (@pxref{Définition des paquets}). La syntaxe générale est : @@ -6449,47 +6634,49 @@ La syntaxe générale est : guix import @var{importer} @var{options}@dots{} @end example -@var{importer} specifies the source from which to import package metadata, -and @var{options} specifies a package identifier and other options specific -to @var{importer}. Currently, the available ``importers'' are: +@var{importer} spécifie la source depuis laquelle importer des métadonnées +de paquets, et @var{options} spécifie un identifiant de paquet et d'autres +options spécifiques à @var{importer}. Actuellement les « importateurs » +disponibles sont : @table @code @item gnu -Import metadata for the given GNU package. This provides a template for the -latest version of that GNU package, including the hash of its source -tarball, and its canonical synopsis and description. +Importe des métadonnées d'un paquet GNU donné. Cela fournit un modèle pour +la dernière version de ce paquet GNU, avec le hash de son archive, le +synopsis et la description canonique. -Additional information such as the package dependencies and its license -needs to be figured out manually. +Les informations supplémentaires comme les dépendances du paquet et sa +licence doivent être renseignées manuellement. -For example, the following command returns a package definition for -GNU@tie{}Hello: +Par exemple, la commande suivante renvoie une définition de paquets pour +GNU@tie{}Hello : @example guix import gnu hello @end example -Specific command-line options are: +Les options spécifiques sont : @table @code -@item --key-download=@var{policy} -As for @code{guix refresh}, specify the policy to handle missing OpenPGP -keys when verifying the package signature. @xref{Invoquer guix refresh, -@code{--key-download}}. +@item --key-download=@var{politique} +Comme pour @code{guix refresh}, spécifie la politique de gestion des clefs +OpenPGP manquantes lors de la vérification de la signature d'un paquet. +@xref{Invoquer guix refresh, @code{--key-download}}. @end table @item pypi @cindex pypi -Import metadata from the @uref{https://pypi.python.org/, Python Package -Index}@footnote{This functionality requires Guile-JSON to be installed. -@xref{Prérequis}.}. Information is taken from the JSON-formatted -description available at @code{pypi.python.org} and usually includes all the -relevant information, including package dependencies. For maximum -efficiency, it is recommended to install the @command{unzip} utility, so -that the importer can unzip Python wheels and gather data from them. +Importe des métadonnées depuis @uref{https://pypi.python.org/, l'index des +paquets Python}@footnote{Cette fonctionnalité requiert l'installation de +Guile-JSON. @xref{Prérequis}.}. Les informations sont récupérées à +partir de la description en JSON disponible sur @code{pypi.python.org} et +inclus généralement toutes les informations utiles, dont les dépendances des +paquets. Pour une efficacité maximale, il est recommandé d'installer +l'utilitaire @command{unzip}, pour que l'importateur puisse dézipper les +wheels Python et récupérer les informations contenues à l'intérieur. -The command below imports metadata for the @code{itsdangerous} Python -package: +La commande ci-dessous importe les métadonnées du paquet Python +@code{itsdangerous} : @example guix import pypi itsdangerous @@ -6497,35 +6684,44 @@ guix import pypi itsdangerous @item gem @cindex gem -Import metadata from @uref{https://rubygems.org/, RubyGems}@footnote{This -functionality requires Guile-JSON to be installed. @xref{Prérequis}.}. -Information is taken from the JSON-formatted description available at -@code{rubygems.org} and includes most relevant information, including -runtime dependencies. There are some caveats, however. The metadata -doesn't distinguish between synopses and descriptions, so the same string is -used for both fields. Additionally, the details of non-Ruby dependencies -required to build native extensions is unavailable and left as an exercise -to the packager. +Importe des métadonnées de @uref{https://rubygems.org/, +RubyGems}@footnote{Cette fonctionnalité requiert l'installation de +Guile-JSON. @xref{Prérequis}.}. Les informations sont récupérées au +format JSON disponible sur @code{rubygems.org} et inclut les informations +les plus utiles, comme les dépendances à l'exécution. Il y a des pièges +cependant. Les métadonnées ne distinguent pas synopsis et description, donc +la même chaîne est utilisée pour les deux champs. En plus, les détails des +dépendances non Ruby requises pour construire des extensions natives sont +indisponibles et laissé en exercice au packager. -The command below imports metadata for the @code{rails} Ruby package: +La commande ci-dessous importe les métadonnées pour le paquet Ruby +@code{rails} : @example guix import gem rails @end example +@table @code +@item --recursive +@itemx -r +Traverse le graphe des dépendances du paquet amont donné et génère les +expressions de paquets de tous ceux qui ne sont pas déjà dans Guix. +@end table + @item cpan @cindex CPAN -Import metadata from @uref{https://www.metacpan.org/, -MetaCPAN}@footnote{This functionality requires Guile-JSON to be installed. -@xref{Prérequis}.}. Information is taken from the JSON-formatted -metadata provided through @uref{https://fastapi.metacpan.org/, MetaCPAN's -API} and includes most relevant information, such as module dependencies. -License information should be checked closely. If Perl is available in the -store, then the @code{corelist} utility will be used to filter core modules -out of the list of dependencies. +Importe des métadonnées de @uref{https://www.metacpan.org/, +MetaCPAN}@footnote{Cette fonctionnalité requiert l'installation de +Guile-JSON. @xref{Prérequis}.}. Les informations sont récupérées au +format JSON disponible à travers @uref{https://fastapi.metacpan.org/, l'API +de MetaCPAN} et inclus les informations les plus utiles, comme les +dépendances des modules. L'information sur les licences doit être vérifiée +avec attention. Si Perl est disponible dans le dépôt, alors l'utilitaire +@code{corelist} sera utiliser pour exclure les modules du cœur de la +distribution Perl de la liste des dépendances. -The command command below imports metadata for the @code{Acme::Boolean} Perl -module: +La commande ci-dessous importe les métadonnées du module Perl +@code{Acme::Boolean} : @example guix import cpan Acme::Boolean @@ -6534,31 +6730,32 @@ guix import cpan Acme::Boolean @item cran @cindex CRAN @cindex Bioconductor -Import metadata from @uref{https://cran.r-project.org/, CRAN}, the central -repository for the @uref{http://r-project.org, GNU@tie{}R statistical and -graphical environment}. +Importe des métadonnées de @uref{https://cran.r-project.org/, CRAN}, le +dépôt central de @uref{http://r-project.org, l'environnement statistique et +graphique GUN@tie{}R}. -Information is extracted from the @code{DESCRIPTION} file of the package. +Les informations sont extraites du fichier @file{DESCRIPTION} du paquet. -The command command below imports metadata for the @code{Cairo} R package: +La commande ci-dessous importe les métadonnées du paquet R @code{Cairo} : @example guix import cran Cairo @end example -When @code{--recursive} is added, the importer will traverse the dependency -graph of the given upstream package recursively and generate package -expressions for all those packages that are not yet in Guix. +Lorsque l'option @code{--recursive} est utilisée, l'importateur traversera +le graphe des dépendances du paquet amont récursivement et générera des +expressions de paquets pour tous ceux qui ne sont pas déjà dans Guix. -When @code{--archive=bioconductor} is added, metadata is imported from -@uref{https://www.bioconductor.org/, Bioconductor}, a repository of R -packages for for the analysis and comprehension of high-throughput genomic -data in bioinformatics. +Lorsque l'option @code{--archive=bioconductor} est utilisée, les métadonnées +sont importées de @uref{https://www.bioconductor.org/, Bioconductor}, un +répertoire de paquets R pour l'analyse et la compréhension de données +génomiques volumineuses en bioinformatique. -Information is extracted from the @code{DESCRIPTION} file of a package -published on the web interface of the Bioconductor SVN repository. +Les informations sont extraites du fichier @file{DESCRIPTION} d'un paquet +publié sur l'interface web du dépôt SVN de Bioconductor. -The command below imports metadata for the @code{GenomicRanges} R package: +La commande ci-dessous importe les métadonnées du paquet R +@code{GenomicRanges} : @example guix import cran --archive=bioconductor GenomicRanges @@ -6567,29 +6764,30 @@ guix import cran --archive=bioconductor GenomicRanges @item texlive @cindex TeX Live @cindex CTAN -Import metadata from @uref{http://www.ctan.org/, CTAN}, the comprehensive -TeX archive network for TeX packages that are part of the -@uref{https://www.tug.org/texlive/, TeX Live distribution}. +Importe les métadonnées de @uref{http://www.ctan.org/, CTAN}, l'archive TeX +réseau complète pour les paquets TeX qui font partie de la +@uref{https://www.tug.org/texlive/, distribution TeX Live}. -Information about the package is obtained through the XML API provided by -CTAN, while the source code is downloaded from the SVN repository of the Tex -Live project. This is done because the CTAN does not keep versioned -archives. +Les informations sur les paquets sont obtenues à travers l'API XML fournie +par CTAN, tandis que le code source est téléchargé depuis le dépôt SVN du +projet Tex Live. Cette méthode est utilisée parce que CTAN ne garde pas +d'archives versionnées. -The command command below imports metadata for the @code{fontspec} TeX -package: +La commande ci-dessous importe les métadonnées du paquet TeX @code{fontspec} +: @example guix import texlive fontspec @end example -When @code{--archive=DIRECTORY} is added, the source code is downloaded not -from the @file{latex} sub-directory of the @file{texmf-dist/source} tree in -the TeX Live SVN repository, but from the specified sibling directory under -the same root. +Lorsque l'option @code{--archive=DIRECTORY} est utilisée, le code source +n'est pas téléchargé depuis le sous-répertoire @file{latex} du +l'arborescence @file{texmf-dist/source} dans le dépôt SVN de TeX Live, mais +depuis le répertoire voisin spécifié sous la même racine. -The command below imports metadata for the @code{ifxetex} package from CTAN -while fetching the sources from the directory @file{texmf/source/generic}: +La commande ci-dessous importe les métadonnées du paquet @code{ifxetex} +depuis CTAN en récupérant les sources depuis le répertoire +@file{texmf/source/generic} : @example guix import texlive --archive=generic ifxetex @@ -6597,9 +6795,10 @@ guix import texlive --archive=generic ifxetex @item json @cindex JSON, import -Import package metadata from a local JSON file@footnote{This functionality -requires Guile-JSON to be installed. @xref{Prérequis}.}. Consider the -following example package definition in JSON format: +Importe des métadonnées d'un fichier JSON local@footnote{Cette +fonctionnalité requiert l'installation de Guile-JSON. +@xref{Prérequis}.}. Considérez l'exemple suivant d'une définition de +paquet au format JSON : @example @{ @@ -6615,13 +6814,13 @@ following example package definition in JSON format: @} @end example -The field names are the same as for the @code{} record -(@xref{Définition des paquets}). References to other packages are provided as -JSON lists of quoted package specification strings such as @code{guile} or -@code{guile@@2.0}. +Les noms des champs sont les mêmes que pour les enregistrements de +@code{} (@xref{Définition des paquets}). Les référence à d'autres +paquets sont fournies comme des listes JSON de chaînes de spécifications de +paquets comme @code{guile} ou @code{guile@@2.0}. -The importer also supports a more explicit source definition using the -common fields for @code{} records: +L'importateur supporte aussi une définition plus explicite des sources avec +les champs habituels pour les enregistrements @code{} : @example @{ @@ -6637,37 +6836,39 @@ common fields for @code{} records: @} @end example -The command below reads metadata from the JSON file @code{hello.json} and -outputs a package expression: +La commande ci-dessous lit les métadonnées du fichier JSON @code{hello.json} +et renvoie une expression de paquet : @example guix import json hello.json @end example @item nix -Import metadata from a local copy of the source of the -@uref{http://nixos.org/nixpkgs/, Nixpkgs distribution}@footnote{This relies -on the @command{nix-instantiate} command of @uref{http://nixos.org/nix/, -Nix}.}. Package definitions in Nixpkgs are typically written in a mixture -of Nix-language and Bash code. This command only imports the high-level -package structure that is written in the Nix language. It normally includes -all the basic fields of a package definition. +Importe les métadonnées d'une copie locale des source de +@uref{http://nixos.org/nixpkgs/, la distribution Nixpkgs}@footnote{Cela +repose sur la commande @command{nix-instantiate} de +@uref{http://nixos.org/nix/, Nix}.}. Les définitions de paquets dans +Nixpkgs sont habituellement écrites en un mélange entre le langage Nix et +Bash. Cette commande n'importe que la structure de haut-niveau du paquet +qui est écrite dans le langage Nix. Elle inclut normalement tous les champs +de base de la définition d'un paquet. -When importing a GNU package, the synopsis and descriptions are replaced by -their canonical upstream variant. +Lorsque vous importez un paquet GNU, le synopsis et la description sont +replacés par la version canonique en amont. -Usually, you will first need to do: +Normalement, vous devrez d'abord faire : @example export NIX_REMOTE=daemon @end example @noindent -so that @command{nix-instantiate} does not try to open the Nix database. +pour que @command{nix-instantiate} n'essaye pas d'ouvrir la base de données +de Nix. -As an example, the command below imports the package definition of -LibreOffice (more precisely, it imports the definition of the package bound -to the @code{libreoffice} top-level attribute): +Par exemple, la commande ci-dessous importe la définition du paquet de +LibreOffice (plus précisément, elle importe la définition du paquet lié à +l'attribut de plus haut-niveau @code{libreoffice}) : @example guix import nix ~/path/to/nixpkgs libreoffice @@ -6675,42 +6876,48 @@ guix import nix ~/path/to/nixpkgs libreoffice @item hackage @cindex hackage -Import metadata from the Haskell community's central package archive -@uref{https://hackage.haskell.org/, Hackage}. Information is taken from -Cabal files and includes all the relevant information, including package -dependencies. +Importe les métadonnées de l'archive de paquets centrale de la communauté +Haskell, @uref{https://hackage.haskell.org/, Hackage}. Les informations +sont récupérées depuis les fichiers Cabal et incluent toutes les +informations utiles, dont les dépendances des paquets. -Specific command-line options are: +Les options spécifiques sont : @table @code @item --stdin @itemx -s -Read a Cabal file from standard input. +Lit un fichier Cabal depuis l'entrée standard. @item --no-test-dependencies @itemx -t -Do not include dependencies required only by the test suites. +N'inclut pas les dépendances requises uniquement par les suites de tests. @item --cabal-environment=@var{alist} @itemx -e @var{alist} -@var{alist} is a Scheme alist defining the environment in which the Cabal -conditionals are evaluated. The accepted keys are: @code{os}, @code{arch}, -@code{impl} and a string representing the name of a flag. The value -associated with a flag has to be either the symbol @code{true} or -@code{false}. The value associated with other keys has to conform to the -Cabal file format definition. The default value associated with the keys -@code{os}, @code{arch} and @code{impl} is @samp{linux}, @samp{x86_64} and -@samp{ghc}, respectively. +@var{alist} est une alist Scheme qui définie l'environnement dans lequel les +conditions de Cabal sont évaluées. Les clefs acceptées sont : @code{os}, +@code{arch}, @code{impl} et une représentation sous forme de chaîne de +caractères du nom d'un drapeau. La valeur associée à un drapeau doit être +le symbole @code{true} ou @code{false}. La valeur associée aux autres clefs +doivent se conformer avec la définition du format de fichiers Cabal. La +valeur par défaut associée avec les clefs @code{os}, @code{arch} et +@code{impl} sont respectivement @samp{linux}, @samp{x86_64} et @samp{ghc}. +@item --recursive +@itemx -r +Traverse le graphe des dépendances du paquet amont donné et génère les +expressions de paquets de tous ceux qui ne sont pas déjà dans Guix. @end table -The command below imports metadata for the latest version of the @code{HTTP} -Haskell package without including test dependencies and specifying the value -of the flag @samp{network-uri} as @code{false}: +La commande ci-dessous importe les métadonnées de la dernière version du +paquet Haskell @code{HTTP} sans inclure les dépendances des tests et en +spécifiant la valeur du drapeau @samp{network-uri} comme étant @code{false} +: @example guix import hackage -t -e "'((\"network-uri\" . false))" HTTP @end example -A specific package version may optionally be specified by following the -package name by an at-sign and a version number as in the following example: +Une version spécifique du paquet peut éventuellement être spécifiée en +faisant suivre le nom du paquet par un arobase et un numéro de version comme +dans l'exemple suivant : @example guix import hackage mtl@@2.1.3.1 @@ -6718,26 +6925,27 @@ guix import hackage mtl@@2.1.3.1 @item stackage @cindex stackage -The @code{stackage} importer is a wrapper around the @code{hackage} one. It -takes a package name, looks up the package version included in a long-term -support (LTS) @uref{https://www.stackage.org, Stackage} release and uses the -@code{hackage} importer to retrieve its metadata. Note that it is up to you -to select an LTS release compatible with the GHC compiler used by Guix. +L'importateur @code{stackage} est une enveloppe autour de l'importateur +@code{hackage}. Il prend un nom de paquet, recherche la version incluse +dans une version au support étendu (LTS) de @uref{https://www.stackage.org, +Stackage} et utilise l'importateur @code{hackage} pour récupérer les +métadonnées. Remarquez que c'est à vous de choisir une version LTS +compatible avec le compilateur GHC utilisé par Guix. -Specific command-line options are: +Les options spécifiques sont : @table @code @item --no-test-dependencies @itemx -t -Do not include dependencies required only by the test suites. +N'inclut pas les dépendances requises uniquement par les suites de tests. @item --lts-version=@var{version} @itemx -r @var{version} -@var{version} is the desired LTS release version. If omitted the latest -release is used. +@var{version} est la version LTS désirée. Si elle est omise, la dernière +version est utilisée. @end table -The command below imports metadata for the @code{HTTP} Haskell package -included in the LTS Stackage release version 7.18: +La commande ci-dessous importe les métadonnées du paquet Haskell @code{HTTP} +inclus dans la version LTS 7.18 de Stackage : @example guix import stackage --lts-version=7.18 HTTP @@ -6745,89 +6953,96 @@ guix import stackage --lts-version=7.18 HTTP @item elpa @cindex elpa -Import metadata from an Emacs Lisp Package Archive (ELPA) package repository -(@pxref{Packages,,, emacs, The GNU Emacs Manual}). +Importe les métadonnées du dépôt de paquets ELPA (Emacs Lisp Package +Archive) (@pxref{Packages,,, emacs, The GNU Emacs Manual}). -Specific command-line options are: +Les options spécifiques sont : @table @code @item --archive=@var{repo} @itemx -a @var{repo} -@var{repo} identifies the archive repository from which to retrieve the -information. Currently the supported repositories and their identifiers -are: +@var{repo} identifie le dépôt d'archive depuis lequel récupérer les +informations. Actuellement les dépôts supportés et leurs identifiants sont +: @itemize - @item -@uref{http://elpa.gnu.org/packages, GNU}, selected by the @code{gnu} -identifier. This is the default. +@uref{http://elpa.gnu.org/packages, GNU}, qu'on peut choisir avec +l'identifiant @code{gnu}. C'est la valeur par défaut. -Packages from @code{elpa.gnu.org} are signed with one of the keys contained -in the GnuPG keyring at @file{share/emacs/25.1/etc/package-keyring.gpg} (or -similar) in the @code{emacs} package (@pxref{Package Installation, ELPA +Les paquets de @code{elpa.gnu.org} avec l'une des clefs contenues dans le +porte-clef GnuPG @file{share/emacs/25.1/etc/package-keyring.gpg} (ou +similaire) dans le paquet @code{emacs} (@pxref{Package Installation, ELPA package signatures,, emacs, The GNU Emacs Manual}). @item -@uref{http://stable.melpa.org/packages, MELPA-Stable}, selected by the -@code{melpa-stable} identifier. +@uref{http://stable.melpa.org/packages, MELPA-Stable}, qu'on peut +sélectionner avec l'identifiant @code{melpa-stable}. @item -@uref{http://melpa.org/packages, MELPA}, selected by the @code{melpa} -identifier. +@uref{http://melpa.org/packages, MELPA}, qu'on peut sélectionner avec +l'identifiant @code{melpa}. @end itemize @item --recursive @itemx -r -Traverse the dependency graph of the given upstream package recursively and -generate package expressions for all those packages that are not yet in -Guix. +Traverse le graphe des dépendances du paquet amont donné et génère les +expressions de paquets de tous ceux qui ne sont pas déjà dans Guix. @end table @item crate @cindex crate -Import metadata from the crates.io Rust package repository +Importe les métadonnées du répertoire des paquets Rust @uref{https://crates.io, crates.io}. + +@item opam +@cindex OPAM +@cindex OCaml +Import metadata from the @uref{https://opam.ocaml.org/, OPAM} package +repository used by the OCaml community. @end table -The structure of the @command{guix import} code is modular. It would be -useful to have more importers for other package formats, and your help is -welcome here (@pxref{Contribuer}). +La structure du code de @command{guix import} est modulaire. Il serait +utile d'avoir plus d'importateurs pour d'autres formats de paquets et votre +aide est la bienvenue sur ce sujet (@pxref{Contribuer}). @node Invoquer guix refresh -@section Invoking @command{guix refresh} +@section Invoquer @command{guix refresh} @cindex @command{guix refresh} -The primary audience of the @command{guix refresh} command is developers of -the GNU software distribution. By default, it reports any packages provided -by the distribution that are outdated compared to the latest upstream -version, like this: +L'audience première de la commande @command{guix refresh} est l'ensemble des +développeurs de la distribution logicielle GNU. Par défaut, elle rapporte +les paquets fournis par la distribution qui sont en retard par rapport aux +dernières versions disponibles en amont, comme ceci : @example $ guix refresh -gnu/packages/gettext.scm:29:13: gettext would be upgraded from 0.18.1.1 to 0.18.2.1 -gnu/packages/glib.scm:77:12: glib would be upgraded from 2.34.3 to 2.37.0 +gnu/packages/gettext.scm:29:13: gettext serait mis à jour de 0.18.1.1 à 0.18.2.1 +gnu/packages/glib.scm:77:12: glib serait mis à jour de 2.34.3 à 2.37.0 @end example -Alternately, one can specify packages to consider, in which case a warning -is emitted for packages that lack an updater: +Autrement, on peut spécifier les paquets à considérer, auquel cas un +avertissement est émis pour les paquets qui n'ont pas de gestionnaire de +mise à jour associé : @example $ guix refresh coreutils guile guile-ssh -gnu/packages/ssh.scm:205:2: warning: no updater for guile-ssh -gnu/packages/guile.scm:136:12: guile would be upgraded from 2.0.12 to 2.0.13 +gnu/packages/ssh.scm:205:2 : avertissement : aucun gestionnaire de mise à jour pour guile-ssh +gnu/packages/guile.scm:136:12 : guile serait mis à jour de 2.0.12 à 2.0.13 @end example -@command{guix refresh} browses the upstream repository of each package and -determines the highest version number of the releases therein. The command -knows how to update specific types of packages: GNU packages, ELPA packages, -etc.---see the documentation for @option{--type} below. There are many -packages, though, for which it lacks a method to determine whether a new -upstream release is available. However, the mechanism is extensible, so -feel free to get in touch with us to add a new method! +@command{guix refresh} navigue le dépôt amont de chaque paquet et détermine +le numéro de version le plus élevé parmi les versions publiées. La commande +sait comment mettre à jour certains types de paquets : les paquets GNU, les +paquets ELPA, etc. — voir la documentation pour @option{--type} ci-dessous. +Il y a beaucoup de paquet cependant pour lesquels il manque une méthode pour +déterminer si une nouvelle version est disponible en amont. Cependant, le +mécanisme est extensible, alors n'hésitez pas à nous contacter pour ajouter +une nouvelle méthode ! -Sometimes the upstream name differs from the package name used in Guix, and -@command{guix refresh} needs a little help. Most updaters honor the -@code{upstream-name} property in package definitions, which can be used to -that effect: +Parfois les noms en amont diffèrent du nom de paquet utilisé par Guix et +@command{guix refresh} a besoin d'un peu d'aide. La plupart des +gestionnaires de mise à jour honorent la propriété @code{upstream-name} dans +les définitions de paquets, ce qui peut être utilisé à cette fin : @example (define-public network-manager @@ -6837,18 +7052,19 @@ that effect: (properties '((upstream-name . "NetworkManager"))))) @end example -When passed @code{--update}, it modifies distribution source files to update -the version numbers and source tarball hashes of those package recipes -(@pxref{Définition des paquets}). This is achieved by downloading each package's -latest source tarball and its associated OpenPGP signature, authenticating -the downloaded tarball against its signature using @command{gpg}, and -finally computing its hash. When the public key used to sign the tarball is -missing from the user's keyring, an attempt is made to automatically -retrieve it from a public key server; when this is successful, the key is -added to the user's keyring; otherwise, @command{guix refresh} reports an -error. +Lorsque l'option @code{--update} est utilisée, elle modifie les fichiers +source de la distribution pour mettre à jour le numéro de version et le hash +de l'archive source de ces recettes de paquets (@pxref{Définition des paquets}). +Cela est effectué en téléchargeant la dernière version de l'archive des +sources de chaque paquet et des signatures associées, en authentifiant +l'archive téléchargée avec sa signature en utilisant @command{gpg} puis en +calculant son hash. Lorsque la clef publique utilisée pour signer l'archive +manque du porte-clefs de l'utilisateur, le gestionnaire tente de la +récupérer automatiquement d'un serveur de clef public ; si cela réussi, la +clef est ajoutée au porte-clefs de l'utilisateur, sinon @command{guix +refresh} rapporte une erreur. -The following options are supported: +Les options suivantes sont supportées : @table @code @@ -6856,136 +7072,155 @@ The following options are supported: @itemx -e @var{expr} Considérer le paquet évalué par @var{expr}. -This is useful to precisely refer to a package, as in this example: +C'est utile pour précisément se référer à un paquet, comme dans cet exemple +: @example guix refresh -l -e '(@@@@ (gnu packages commencement) glibc-final)' @end example -This command lists the dependents of the ``final'' libc (essentially all the -packages.) +Cette commande liste les paquets qui dépendent de la libc « finale » (en +gros tous les paquets). @item --update @itemx -u -Update distribution source files (package recipes) in place. This is -usually run from a checkout of the Guix source tree (@pxref{Lancer Guix avant qu'il ne soit installé}): +Met à jour les fichiers source de la distribution (les recettes de paquets) +en place. Cette option est généralement utilisée depuis une copie du dépôt +git de Guix (@pxref{Lancer Guix avant qu'il ne soit installé}) : @example $ ./pre-inst-env guix refresh -s non-core -u @end example -@xref{Définition des paquets}, for more information on package definitions. +@xref{Définition des paquets}, pour plus d'information sur les définitions des +paquets. @item --select=[@var{subset}] @itemx -s @var{subset} -Select all the packages in @var{subset}, one of @code{core} or +Choisi tous les paquets dans @var{subset}, entre @code{core} et @code{non-core}. -The @code{core} subset refers to all the packages at the core of the -distribution---i.e., packages that are used to build ``everything else''. -This includes GCC, libc, Binutils, Bash, etc. Usually, changing one of -these packages in the distribution entails a rebuild of all the others. -Thus, such updates are an inconvenience to users in terms of build time or -bandwidth used to achieve the upgrade. +Le sous-ensemble @code{core} se réfère à tous les paquets du cœur de la +distribution — c.-à-d.@: les paquets qui sont utilisés pour construire « +tout le rest ». Cela comprend GCC, libc, Binutils, Bash, etc. +Habituellement, changer l'un de ces paquets dans la distribution implique de +reconstruire tous les autres. Ainsi, ces mises à jour sont une nuisance +pour les utilisateurs, en terme de temps de compilation et de bande passante +utilisés pour effectuer la mise à jour. -The @code{non-core} subset refers to the remaining packages. It is -typically useful in cases where an update of the core packages would be -inconvenient. +Le sous-ensemble @code{non-core} se réfère au reste des paquets. C'est +habituellement utile dans les cas où une mise à jour des paquets du cœur +serait dérangeante. @item --manifest=@var{fichier} @itemx -m @var{fichier} -Select all the packages from the manifest in @var{file}. This is useful to -check if any packages of the user manifest can be updated. +Choisi tous les paquets du manifeste dans @var{file}. C'est utile pour +vérifier qu'aucun des paquets du manifeste utilisateur ne peut être mis à +jour. @item --type=@var{updater} @itemx -t @var{updater} -Select only packages handled by @var{updater} (may be a comma-separated list -of updaters). Currently, @var{updater} may be one of: +Chois uniquement les paquets pris en charge par @var{updater} +(éventuellement une liste de gestionnaires de mise à jour séparés par des +virgules). Actuellement, @var{updater} peut être l'une des valeurs suivantes +: @table @code @item gnu -the updater for GNU packages; +le gestionnaire de mise à jour pour les paquets GNU ; @item gnome -the updater for GNOME packages; +le gestionnaire de mise à jour pour les paquets GNOME ; @item kde -the updater for KDE packages; +le gestionnaire de mise à jour pour les paquets KDE ; @item xorg -the updater for X.org packages; +le gestionnaire de mise à jour pour les paquets X.org ; @item kernel.org -the updater for packages hosted on kernel.org; +le gestionnaire de mise à jour pour les paquets hébergés sur kernel.org ; @item elpa -the updater for @uref{http://elpa.gnu.org/, ELPA} packages; +le gestionnaire de mise à jour pour les paquets @uref{http://elpa.gnu.org/, +ELPA} ; @item cran -the updater for @uref{https://cran.r-project.org/, CRAN} packages; +le gestionnaire de mise à jour pour les paquets +@uref{https://cran.r-project.org/, CRAN} ; @item bioconductor -the updater for @uref{https://www.bioconductor.org/, Bioconductor} R -packages; +le gestionnaire de mise à jour pour les paquets +@uref{https://www.bioconductor.org/, Bioconductor} ; @item cpan -the updater for @uref{http://www.cpan.org/, CPAN} packages; +le gestionnaire de mise à jour pour les paquets @uref{http://www.cpan.org/, +CPAN} ; @item pypi -the updater for @uref{https://pypi.python.org, PyPI} packages. +le gestionnaire de mise à jour pour les paquets +@uref{https://pypi.python.org, PyPI} ; @item gem -the updater for @uref{https://rubygems.org, RubyGems} packages. +le gestionnaire de mise à jour pour les paquets @uref{https://rubygems.org, +RubyGems} ; @item github -the updater for @uref{https://github.com, GitHub} packages. +le gestionnaire de mise à jour pour les paquets @uref{https://github.com, +GitHub} ; @item hackage -the updater for @uref{https://hackage.haskell.org, Hackage} packages. +le gestionnaire de mise à jour pour les paquets +@uref{https://hackage.haskell.org, Hackage} ; @item stackage -the updater for @uref{https://www.stackage.org, Stackage} packages. +le gestionnaire de mise à jour pour les paquets +@uref{https://www.stackage.org, Stackage} ; @item crate -the updater for @uref{https://crates.io, Crates} packages. +le gestionnaire de mise à jour pour les paquets @uref{https://crates.io, +Crates} ; @end table -For instance, the following command only checks for updates of Emacs -packages hosted at @code{elpa.gnu.org} and for updates of CRAN packages: +Par exemple, la commande suivante ne vérifie que les mises à jour des +paquets Emacs hébergés sur @code{elpa.gnu.org} et les paquets CRAN : @example $ guix refresh --type=elpa,cran -gnu/packages/statistics.scm:819:13: r-testthat would be upgraded from 0.10.0 to 0.11.0 -gnu/packages/emacs.scm:856:13: emacs-auctex would be upgraded from 11.88.6 to 11.88.9 +gnu/packages/statistics.scm:819:13 : r-testthat serait mis à jour de 0.10.0 à 0.11.0 +gnu/packages/emacs.scm:856:13 : emacs-auctex serait mis à jour de 11.88.6 à 11.88.9 @end example @end table -In addition, @command{guix refresh} can be passed one or more package names, -as in this example: +En plus, on peut passer à @command{guix refresh} un ou plusieurs noms de +paquets, comme dans cet exemple : @example $ ./pre-inst-env guix refresh -u emacs idutils gcc@@4.8 @end example @noindent -The command above specifically updates the @code{emacs} and @code{idutils} -packages. The @code{--select} option would have no effect in this case. +La commande au-dessus met à jour spécifiquement les paquets @code{emacs} et +@code{idutils}. L'option @code{--select} n'aurait aucun effet dans ce cas. -When considering whether to upgrade a package, it is sometimes convenient to -know which packages would be affected by the upgrade and should be checked -for compatibility. For this the following option may be used when passing -@command{guix refresh} one or more package names: +Pour déterminer s'il faut mettre à jour un paquet, il est parfois pratique +de savoir quels paquets seraient affectés par la mise à jour pour pouvoir +vérifier la compatibilité. Pour cela l'option suivante peut être utilisée +avec un ou plusieurs noms de paquets passés à @command{guix refresh} : @table @code @item --list-updaters @itemx -L -List available updaters and exit (see @option{--type} above.) +Liste les gestionnaires de mise à jour et quitte (voir l'option +@option{--type} plus haut). -For each updater, display the fraction of packages it covers; at the end, -display the fraction of packages covered by all these updaters. +Pour chaque gestionnaire, affiche le pourcentage de paquets qu'il couvre ; à +la fin, affiche le pourcentage de paquets couverts par tous les +gestionnaires. @item --list-dependent @itemx -l -List top-level dependent packages that would need to be rebuilt as a result -of upgrading one or more packages. +Liste les paquets de plus haut-niveau qui devraient être reconstruits après +la mise à jour d'un ou plusieurs paquets. -@xref{Invoquer guix graph, the @code{reverse-package} type of @command{guix -graph}}, for information on how to visualize the list of dependents of a -package. +@xref{Invoquer guix graph, le type @code{reverse-package} de @command{guix +graph}}, pour des informations sur la manière de visualiser la liste des +paquets dépendant d'un autre. @end table -Be aware that the @code{--list-dependent} option only @emph{approximates} -the rebuilds that would be required as a result of an upgrade. More -rebuilds might be required under some circumstances. +Soyez conscients que l'option @code{--list-dependent} ne fait +@emph{qu'approximer} les reconstructions qui seraient requises par une mise +à jour. Plus de reconstructions pourraient être requises dans certaines +circonstances. @example $ guix refresh --list-dependent flex @@ -6993,102 +7228,114 @@ Building the following 120 packages would ensure 213 dependent packages are rebu hop@@2.4.0 geiser@@0.4 notmuch@@0.18 mu@@0.9.9.5 cflow@@1.4 idutils@@4.6 @dots{} @end example -The command above lists a set of packages that could be built to check for -compatibility with an upgraded @code{flex} package. +La commande ci-dessus liste un ensemble de paquets qui peuvent être +construits pour vérifier la compatibilité d'une mise à jour de @code{flex}. -The following options can be used to customize GnuPG operation: +Les options suivante peuvent être utilisées pour personnaliser les +opérations avec GnuPG : @table @code -@item --gpg=@var{command} -Use @var{command} as the GnuPG 2.x command. @var{command} is searched for -in @code{$PATH}. +@item --gpg=@var{commande} +Utilise @var{commande} comme la commande de GnuPG 2.x. @var{commande} est +recherchée dans @code{PATH}. -@item --key-download=@var{policy} -Handle missing OpenPGP keys according to @var{policy}, which may be one of: +@item --key-download=@var{politique} +Gère les clefs OpenPGP manquantes d'après la @var{politique}, qui peut être +l'une des suivantes : @table @code @item always -Always download missing OpenPGP keys from the key server, and add them to -the user's GnuPG keyring. +Toujours télécharger les clefs manquantes depuis un serveur de clefs et les +ajouter au porte-clefs de l'utilisateur. @item never -Never try to download missing OpenPGP keys. Instead just bail out. +Ne jamais essayer de télécharger les clefs OpenPGP manquante. Quitter à la +place. @item interactive -When a package signed with an unknown OpenPGP key is encountered, ask the -user whether to download it or not. This is the default behavior. +Lorsqu'on rencontre un paquet signé par une clef OpenPGP inconnue, demander +à l'utilisateur s'il souhaite la télécharger ou non. C'est le comportement +par défaut. @end table @item --key-server=@var{host} -Use @var{host} as the OpenPGP key server when importing a public key. +Utiliser @var{host} comme serveur de clefs OpenPGP lors de l'importe d'une +clef publique. @end table -The @code{github} updater uses the @uref{https://developer.github.com/v3/, -GitHub API} to query for new releases. When used repeatedly e.g. when -refreshing all packages, GitHub will eventually refuse to answer any further -API requests. By default 60 API requests per hour are allowed, and a full -refresh on all GitHub packages in Guix requires more than this. -Authentication with GitHub through the use of an API token alleviates these -limits. To use an API token, set the environment variable -@code{GUIX_GITHUB_TOKEN} to a token procured from -@uref{https://github.com/settings/tokens} or otherwise. +Le gestionnaire de mises à jour @code{github} utilise +@uref{https://developer.github.com/v3/, l'API de GitHub} pour faire des +requêtes sur les nouvelles versions. Lorsqu'elle est utilisé de manière +répétée, p.@: ex.@: lorsque vous vérifiez tous les paquets, GitHub finira +par refuser de répondre à d'autres requêtes de l'API. Par défaut 60 +requêtes à l'heure sont autorisées, et une vérification complète de tous les +paquets GitHub dans Guix requiert bien plus que cela. L'authentification +avec GitHub à travers l'utilisation d'un jeton d'API lève ces limites. Pour +utiliser un jeton de l'API, initialisez la variable d'environnement +@code{GUIX_GITHUB_TOKEN} avec un jeton que vous vous serez procuré sur +@uref{https://github.com/settings/tokens} ou autrement. @node Invoquer guix lint -@section Invoking @command{guix lint} +@section Invoquer @command{guix lint} @cindex @command{guix lint} -@cindex package, checking for errors -The @command{guix lint} command is meant to help package developers avoid -common errors and use a consistent style. It runs a number of checks on a -given set of packages in order to find common mistakes in their -definitions. Available @dfn{checkers} include (see @code{--list-checkers} -for a complete list): +@cindex paquets, chercher des erreurs +La commande @command{guix lint} est conçue pour aider les développeurs à +éviter des erreurs commune et à utiliser un style cohérent lors de +l'écriture de recettes de paquets. Elle lance des vérifications sur un +ensemble de paquets donnés pour trouver des erreurs communes dans leur +définition. Les @dfn{vérifieurs} disponibles comprennent (voir +@code{--list-checkers} pour une liste complète) : @table @code @item synopsis @itemx description -Validate certain typographical and stylistic rules about package -descriptions and synopses. +Vérifie certaines règles typographiques et stylistiques dans les +descriptions et les synopsis. @item inputs-should-be-native -Identify inputs that should most likely be native inputs. +Identifie les entrées qui devraient sans doute plutôt être des entrées +natives. @item source @itemx home-page @itemx mirror-url @itemx source-file-name -Probe @code{home-page} and @code{source} URLs and report those that are -invalid. Suggest a @code{mirror://} URL when applicable. Check that the -source file name is meaningful, e.g. is not just a version number or -``git-checkout'', without a declared @code{file-name} (@pxref{Référence d'origine}). +Sonde les URL @code{home-page} et @code{source} et rapporte celles qui sont +invalides. Suggère une URL en @code{mirror://} lorsque c'est possible. +Vérifie que le nom du fichier source a un sens, p.@: ex.@: qu'il ne s'agisse +pas juste d'un numéro de version ou « git-checkou », sans avoir déclaré un +@code{file-name} (@pxref{Référence d'origine}). @item cve -@cindex security vulnerabilities +@cindex vulnérabilités @cindex CVE, Common Vulnerabilities and Exposures -Report known vulnerabilities found in the Common Vulnerabilities and -Exposures (CVE) databases of the current and past year -@uref{https://nvd.nist.gov/download.cfm#CVE_FEED, published by the US NIST}. +Rapporte les vulnérabilités connues trouvées dans les bases de données CVE +(Common Vulnerabilities and Exposures) de l'année en cours et des années +précédentes @uref{https://nvd.nist.gov/download.cfm#CVE_FEED, publié par le +NIST américain}. -To view information about a particular vulnerability, visit pages such as: +Pour voir les informations sur une vulnérabilité en particulier, visitez les +pages : @itemize @item -@indicateurl{https://web.nvd.nist.gov/view/vuln/detail?vulnId=CVE-YYYY-ABCD} +@indicateurl{https://web.nvd.nist.gov/view/vuln/detail?vulnId=CVE-ANNÉE-ABCD} @item -@indicateurl{https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-YYYY-ABCD} +@indicateurl{https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-ANNÉE-ABCD} @end itemize @noindent -where @code{CVE-YYYY-ABCD} is the CVE identifier---e.g., +où @code{CVE-ANNÉE-ABCD} est l'identifiant CVE — p.@: ex.@: @code{CVE-2015-7554}. -Package developers can specify in package recipes the -@uref{https://nvd.nist.gov/cpe.cfm,Common Platform Enumeration (CPE)} name -and version of the package when they differ from the name or version that -Guix uses, as in this example: +Les développeurs de paquets peuvent spécifier dans les recettes des paquets +le nom @uref{https://nvd.nist.gov/cpe.cfm,CPE (Common Platform Enumeration)} +et la version du paquet s'ils diffèrent du nom et de la version que Guix +utilise, comme dans cet exemple : @example (package @@ -7100,16 +7347,16 @@ Guix uses, as in this example: @end example @c See . -Some entries in the CVE database do not specify which version of a package -they apply to, and would thus ``stick around'' forever. Package developers -who found CVE alerts and verified they can be ignored can declare them as in -this example: +Certaines entrées dans la base de données CVE ne spécifient pas la version +du paquet auquel elles s'appliquent et lui restera donc attachée pour +toujours. Les développeurs qui trouvent des alertes CVE et ont vérifiés +qu'elles peuvent être ignorées peuvent les déclarer comme dans cet exemple : @example (package (name "t1lib") ;; @dots{} - ;; These CVEs no longer apply and can be safely ignored. + ;; Ces CVE ne s'appliquent plus et peuvent être ignorée sans problème. (properties `((lint-hidden-cve . ("CVE-2011-0433" "CVE-2011-1553" "CVE-2011-1554" @@ -7117,8 +7364,8 @@ this example: @end example @item formatting -Warn about obvious source code formatting issues: trailing white space, use -of tabulations, etc. +Avertit le développeurs lorsqu'il y a des problèmes de formatage du code +source évident : des espaces en fin de ligne, des tabulations, etc. @end table La syntaxe générale est : @@ -7127,38 +7374,40 @@ La syntaxe générale est : guix lint @var{options} @var{package}@dots{} @end example -If no package is given on the command line, then all packages are checked. -The @var{options} may be zero or more of the following: +Si aucun paquet n'est donné par la ligne de commande, tous les paquets +seront vérifiés. Les @var{options} peuvent contenir aucune ou plus des +options suivantes : @table @code @item --list-checkers @itemx -l -List and describe all the available checkers that will be run on packages -and exit. +Liste et décrit tous les vérificateurs disponibles qui seront lancés sur les +paquets puis quitte. @item --checkers @itemx -c -Only enable the checkers specified in a comma-separated list using the names -returned by @code{--list-checkers}. +N'active que les vérificateurs spécifiés dans une liste de noms séparés par +des virgules parmi la liste renvoyée par @code{--list-checkers}. @end table @node Invoquer guix size -@section Invoking @command{guix size} +@section Invoquer @command{guix size} -@cindex size -@cindex package size +@cindex taille +@cindex paquet, taille @cindex closure @cindex @command{guix size} -The @command{guix size} command helps package developers profile the disk -usage of packages. It is easy to overlook the impact of an additional -dependency added to a package, or the impact of using a single output for a -package that could easily be split (@pxref{Des paquets avec plusieurs résultats}). Such are the typical issues that @command{guix size} can -highlight. +La commande @command{guix size} aide les développeurs à dresser un profil de +l'utilisation du disque que font les paquets. C'est facile de négliger +l'impact d'une dépendance supplémentaire ajoutée à un paquet, ou l'impact de +l'utilisation d'une sortie unique pour un paquet qui pourrait être +facilement séparé (@pxref{Des paquets avec plusieurs résultats}). Ce sont les +problèmes que @command{guix size} peut typiquement mettre en valeur. -The command can be passed one or more package specifications such as -@code{gcc@@4.8} or @code{guile:debug}, or a file name in the store. -Consider this example: +On peut passer un ou plusieurs spécifications de paquets à la commande, +comme @code{gcc@@4.8} ou @code{guile:debug}, ou un nom de fichier dans le +dépôt. Regardez cet exemple : @example $ guix size coreutils @@ -7175,34 +7424,36 @@ total: 78.9 MiB @end example @cindex closure -The store items listed here constitute the @dfn{transitive closure} of -Coreutils---i.e., Coreutils and all its dependencies, recursively---as would -be returned by: +Les éléments du dépôt listés ici constituent la @dfn{cloture transitive} de +Coreutils — c.-à-d.@: Coreutils et toutes ses dépendances, récursivement — +comme ce qui serait renvoyé par : @example $ guix gc -R /gnu/store/@dots{}-coreutils-8.23 @end example -Here the output shows three columns next to store items. The first column, -labeled ``total'', shows the size in mebibytes (MiB) of the closure of the -store item---that is, its own size plus the size of all its dependencies. -The next column, labeled ``self'', shows the size of the item itself. The -last column shows the ratio of the size of the item itself to the space -occupied by all the items listed here. +Ici, la sortie possède trois colonnes à côté de chaque élément du dépôt. La +première colonne, nommée « total », montre la taille en mébioctet (Mio) de +la cloture de l'élément du dépôt — c'est-à-dire sa propre taille plus la +taille de ses dépendances. La colonne suivante, nommée « lui-même », montre +la taille de l'élément lui-même. La dernière colonne montre le ration de la +taille de l'élément lui-même par rapport à celle de tous les éléments +montrés. -In this example, we see that the closure of Coreutils weighs in at -79@tie{}MiB, most of which is taken by libc and GCC's run-time support -libraries. (That libc and GCC's libraries represent a large fraction of the -closure is not a problem @i{per se} because they are always available on the -system anyway.) +Dans cet exemple, on voit que la cloture de Coreutils pèse 79@tie{}Mio, dont +la plupart est dû à la libc et aux bibliothèques à l'exécution de GCC (ce +n'est pas un problème en soit que la libc et les bibliothèques de GCC +représentent une grande part de la cloture parce qu'elles sont toujours +disponibles sur le système de toute façon). -When the package(s) passed to @command{guix size} are available in the -store@footnote{More precisely, @command{guix size} looks for the -@emph{ungrafted} variant of the given package(s), as returned by @code{guix -build @var{package} --no-grafts}. @xref{Mises à jour de sécurité}, for information -on grafts.}, @command{guix size} queries the daemon to determine its -dependencies, and measures its size in the store, similar to @command{du -ms ---apparent-size} (@pxref{du invocation,,, coreutils, GNU Coreutils}). +Lorsque les paquets passés à @command{guix size} sont disponibles dans le +dépôt@footnote{Plus précisément, @command{guix size} cherche les variantes +@emph{non greffées} des paquets donnés, tels qu'ils sont renvoyés par +@code{guix build @var{paquet} --no-graft}. @xref{Mises à jour de sécurité} pour des +informations sur les greffes}, @command{guix size} demande au démon de +déterminer ses dépendances, et mesure sa taille dans le dépôt, comme avec +@command{du -ms --apparent-size} (@pxref{du invocation,,, coreutils, GNU +Coreutils}). Lorsque les paquets donnés ne sont @emph{pas} dans le dépôt, @command{guix size} rapporte les informations en se basant sur les substituts disponibles @@ -7210,7 +7461,7 @@ size} rapporte les informations en se basant sur les substituts disponibles éléments du dépôt même s'ils ne sont pas sur le disque, mais disponibles à distance. -You can also specify several package names: +Vous pouvez aussi spécifier plusieurs noms de paquets : @example $ guix size coreutils grep sed bash @@ -7224,218 +7475,225 @@ total: 102.3 MiB @end example @noindent -In this example we see that the combination of the four packages takes -102.3@tie{}MiB in total, which is much less than the sum of each closure -since they have a lot of dependencies in common. +Dans cet exemple on voit que la combinaison des quatre paquets prent +102.3@tie{}Mio en tout, ce qui est bien moins que la somme des clotures +puisqu'ils ont beaucoup de dépendances en commun. -The available options are: +Les options disponibles sont : @table @option @item --substitute-urls=@var{urls} -Use substitute information from @var{urls}. @xref{client-substitute-urls, -the same option for @code{guix build}}. +Utilise les informations de substituts de @var{urls}. +@xref{client-substitute-urls, the same option for @code{guix build}}. -@item --sort=@var{key} -Sort lines according to @var{key}, one of the following options: +@item --sort=@var{clef} +Trie les lignes en fonction de la @var{clef}, l'une des optinos suivantes : @table @code @item self -the size of each item (the default); +la taille de chaque élément (par défaut) ; @item closure -the total size of the item's closure. +la taille totale de la cloture de l'élémente. @end table -@item --map-file=@var{file} -Write a graphical map of disk usage in PNG format to @var{file}. +@item --map-file=@var{fichier} +Écrit un schéma de l'utilisation du disque au format PNG dans @var{fichier}. -For the example above, the map looks like this: +Pour l'exemple au-dessus, le schéma ressemble à ceci : -@image{images/coreutils-size-map,5in,, map of Coreutils disk usage produced -by @command{guix size}} +@image{images/coreutils-size-map,5in,, schéma de l'utilisation du disque de +Coreutils produit par @command{guix size}} -This option requires that -@uref{http://wingolog.org/software/guile-charting/, Guile-Charting} be -installed and visible in Guile's module search path. When that is not the -case, @command{guix size} fails as it tries to load it. +Cette option requiert l'installation de +@uref{http://wingolog.org/software/guile-charting/, Guile-Charting} et qu'il +soit visible dans le chemin de recherche des modules Guile. Lorsque ce +n'est pas le cas, @command{guix size} plante en essayant de le charger. @item --system=@var{système} @itemx -s @var{système} -Consider packages for @var{system}---e.g., @code{x86_64-linux}. +Considère les paquets pour @var{système} — p.@: ex.@: @code{x86_64-linux}. @end table @node Invoquer guix graph -@section Invoking @command{guix graph} +@section Invoque @command{guix graph} @cindex DAG @cindex @command{guix graph} @cindex dépendances des paquets -Packages and their dependencies form a @dfn{graph}, specifically a directed -acyclic graph (DAG). It can quickly become difficult to have a mental model -of the package DAG, so the @command{guix graph} command provides a visual -representation of the DAG. By default, @command{guix graph} emits a DAG -representation in the input format of @uref{http://www.graphviz.org/, -Graphviz}, so its output can be passed directly to the @command{dot} command -of Graphviz. It can also emit an HTML page with embedded JavaScript code to -display a ``chord diagram'' in a Web browser, using the -@uref{https://d3js.org/, d3.js} library, or emit Cypher queries to construct -a graph in a graph database supporting the @uref{http://www.opencypher.org/, -openCypher} query language. The general syntax is: +Les paquets et leurs dépendances forment un @dfn{graphe}, plus précisément +un graphe orienté acyclique (DAG). Il peut vite devenir difficile d'avoir +une représentation mentale du DAG d'un paquet, donc la commande +@command{guix graph} fournit une représentation visuelle du DAG. Par +défaut, @command{guix graph} émet un représentation du DAG dans le format +d'entrée de @uref{http://www.graphviz.org/, Graphviz}, pour que sa sortie +puisse être passée directement à la commande @command{dot} de Graphviz. +Elle peut aussi émettre une page HTML avec du code Javascript pour afficher +un « digramme d'accords » dans un navigateur Web, grâce à la bibliothèque +@uref{https://d3js.org/, d3.js}, ou émettre des requêtes Cypher pour +construire un graphe dans une base de donnée de graphes supportant le +langage de requêtes @uref{http://www.opencypher.org/, openCypher}. La +syntaxe générale est : @example -guix graph @var{options} @var{package}@dots{} +guix graph @var{options} @var{paquet}@dots{} @end example -For example, the following command generates a PDF file representing the -package DAG for the GNU@tie{}Core Utilities, showing its build-time -dependencies: +Par exemple, la commande suivante génère un fichier PDF représentant le DAG +du paquet pour GNU@tie{}Core Utilities, qui montre ses dépendances à la +compilation : @example guix graph coreutils | dot -Tpdf > dag.pdf @end example -The output looks like this: +La sortie ressemble à ceci : -@image{images/coreutils-graph,2in,,Dependency graph of the GNU Coreutils} +@image{images/coreutils-graph,2in,,Graphe de dépendance de GNU Coreutils} -Nice little graph, no? +Joli petit graphe, non ? -But there is more than one graph! The one above is concise: it is the graph -of package objects, omitting implicit inputs such as GCC, libc, grep, etc. -It is often useful to have such a concise graph, but sometimes one may want -to see more details. @command{guix graph} supports several types of graphs, -allowing you to choose the level of detail: +Mais il y a plus qu'un seul graphe ! Celui au-dessus est concis : c'est le +graphe des objets paquets, en omettant les entrées implicites comme GCC, +libc, grep, etc. Il est souvent utile d'avoir ces graphes concis, mais +parfois on veut voir plus de détails. @command{guix graph} supporte +plusieurs types de graphes, qui vous permettent de choisir le niveau de +détails : @table @code @item package -This is the default type used in the example above. It shows the DAG of -package objects, excluding implicit dependencies. It is concise, but -filters out many details. +C'est le type par défaut utilisé dans l'exemple plus haut. Il montre le DAG +des objets paquets, sans les dépendances implicites. C'est concis, mais +omet pas mal de détails. @item reverse-package -This shows the @emph{reverse} DAG of packages. For example: +Cela montre le DAG @emph{inversé} des paquets. Par exemple : @example guix graph --type=reverse-package ocaml @end example -... yields the graph of packages that depend on OCaml. +… montre le graphe des paquets qui dépendent de OCaml. -Note that for core packages this can yield huge graphs. If all you want is -to know the number of packages that depend on a given package, use -@command{guix refresh --list-dependent} (@pxref{Invoquer guix refresh, +Remarquez que pour les paquets du cœur de la distribution, cela crée des +graphes énormes. Si vous voulez seulement voir le nombre de paquets qui +dépendent d'un paquet donnés, utilisez @command{guix refresh +--list-dependent} (@pxref{Invoquer guix refresh, @option{--list-dependent}}). @item bag-emerged -This is the package DAG, @emph{including} implicit inputs. +C'est le DAG du paquet, @emph{avec} les entrées implicites. -For instance, the following command: +Par exemple, la commande suivante : @example guix graph --type=bag-emerged coreutils | dot -Tpdf > dag.pdf @end example -... yields this bigger graph: +… montre ce graphe plus gros : -@image{images/coreutils-bag-graph,,5in,Detailed dependency graph of the GNU -Coreutils} +@image{images/coreutils-bag-graph,,5in,Graphe des dépendances détaillé de +GNU Coreutils} -At the bottom of the graph, we see all the implicit inputs of +En bas du graphe, on voit toutes les entrées implicites de @var{gnu-build-system} (@pxref{Systèmes de construction, @code{gnu-build-system}}). -Now, note that the dependencies of these implicit inputs---that is, the -@dfn{bootstrap dependencies} (@pxref{Bootstrapping})---are not shown here, -for conciseness. +Maintenant, remarquez que les dépendances de ces entrées implicites — +c'est-à-dire les @dfn{dépendances de bootstrap} (@pxref{Bootstrapping}) — ne +sont pas affichées, pour rester concis. @item bag -Similar to @code{bag-emerged}, but this time including all the bootstrap -dependencies. +Comme @code{bag-emerged} mais cette fois inclus toutes les dépendances de +bootstrap. @item bag-with-origins -Similar to @code{bag}, but also showing origins and their dependencies. +Comme @code{bag}, mais montre aussi les origines et leurs dépendances. @item dérivation -This is the most detailed representation: It shows the DAG of derivations -(@pxref{Dérivations}) and plain store items. Compared to the above -representation, many additional nodes are visible, including build scripts, -patches, Guile modules, etc. +C'est la représentation lu plus détaillée : elle montre le DAG des +dérivations (@pxref{Dérivations}) et des éléments du dépôt. Comparé à la +représentation ci-dessus, beaucoup plus de nœuds sont visibles, dont les +scripts de construction, les correctifs, les modules Guile, etc. -For this type of graph, it is also possible to pass a @file{.drv} file name -instead of a package name, as in: +Pour ce type de graphe, il est aussi possible de passer un nom de fichier +@file{.drv} à la place d'un nom de paquet, comme dans : @example guix graph -t derivation `guix system build -d my-config.scm` @end example @item module -This is the graph of @dfn{package modules} (@pxref{Modules de paquets}). For -example, the following command shows the graph for the package module that -defines the @code{guile} package: +C'est le graphe des @dfn{modules de paquets} (@pxref{Modules de paquets}). Par +exemple, la commande suivante montre le graphe des modules de paquets qui +définissent le paquet @code{guile} : @example guix graph -t module guile | dot -Tpdf > module-graph.pdf @end example @end table -All the types above correspond to @emph{build-time dependencies}. The -following graph type represents the @emph{run-time dependencies}: +Tous les types ci-dessus correspondent aux @emph{dépendances à la +construction}. Le type de graphe suivant représente les @emph{dépendances à +l'exécution} : @table @code @item references -This is the graph of @dfn{references} of a package output, as returned by -@command{guix gc --references} (@pxref{Invoquer guix gc}). +C'est le graphe des @dfn{references} d'une sortie d'un paquet, telles que +renvoyées par @command{guix gc --references} (@pxref{Invoquer guix gc}). -If the given package output is not available in the store, @command{guix -graph} attempts to obtain dependency information from substitutes. +Si la sortie du paquet donnée n'est pas disponible dans le dépôt, +@command{guix graph} essayera d'obtenir les informations sur les dépendances +à travers les substituts. -Here you can also pass a store file name instead of a package name. For -example, the command below produces the reference graph of your profile -(which can be big!): +Vous pouvez aussi passer un nom de fichier du dépôt plutôt qu'un nom de +paquet. Par exemple, la commande ci-dessous produit le graphe des +références de votre profile (qui peut être gros !) : @example guix graph -t references `readlink -f ~/.guix-profile` @end example @item referrers -This is the graph of the @dfn{referrers} of a store item, as returned by -@command{guix gc --referrers} (@pxref{Invoquer guix gc}). +C'est le graphe des @dfn{référents} d'un élément du dépôt, tels que renvoyés +par @command{guix gc --referrers} (@pxref{Invoquer guix gc}). -This relies exclusively on local information from your store. For instance, -let us suppose that the current Inkscape is available in 10 profiles on your -machine; @command{guix graph -t referrers inkscape} will show a graph rooted -at Inkscape and with those 10 profiles linked to it. +Cela repose exclusivement sur les informations de votre dépôt. Par exemple, +supposons que Inkscape est actuellement disponible dans 10 profils sur votre +machine ; @command{guix graph -t referrers inkscape} montrera le graphe dont +la racine est Inkscape avec 10 profils qui y sont liés. -It can help determine what is preventing a store item from being garbage -collected. +Cela peut aider à déterminer ce qui empêche un élément du dépôt d'être +glané. @end table -The available options are the following: +Les options disponibles sont les suivante : @table @option @item --type=@var{type} @itemx -t @var{type} -Produce a graph output of @var{type}, where @var{type} must be one of the -values listed above. +Produit un graphe en sortie de type @var{type} où @var{type} doit être l'un +des types au-dessus. @item --list-types -List the supported graph types. +Liste les types de graphes supportés. -@item --backend=@var{backend} -@itemx -b @var{backend} -Produce a graph using the selected @var{backend}. +@item --backend=@var{moteur} +@itemx -b @var{moteur} +Produit un graphe avec le @var{moteur} choisi. @item --list-backends -List the supported graph backends. +Liste les moteurs de graphes supportés. -Currently, the available backends are Graphviz and d3.js. +Actuellement les moteurs disponibles sont Graphviz et d3.js. @item --expression=@var{expr} @itemx -e @var{expr} Considérer le paquet évalué par @var{expr}. -This is useful to precisely refer to a package, as in this example: +C'est utile pour précisément se référer à un paquet, comme dans cet exemple +: @example guix graph -e '(@@@@ (gnu packages commencement) gnu-make-final)' @@ -7444,51 +7702,54 @@ guix graph -e '(@@@@ (gnu packages commencement) gnu-make-final)' @node Invoquer guix environment -@section Invoking @command{guix environment} +@section Invoquer @command{guix environment} -@cindex reproducible build environments -@cindex development environments +@cindex environnements de construction reproductibles +@cindex environnement de développement @cindex @command{guix environment} -@cindex environment, package build environment -The purpose of @command{guix environment} is to assist hackers in creating -reproducible development environments without polluting their package -profile. The @command{guix environment} tool takes one or more packages, -builds all of their inputs, and creates a shell environment to use them. +@cindex environnement de construction de paquets +Le but de @command{guix environment} est d'assister les hackers dans la +création d'environnements de développement reproductibles sans polluer leur +profil de paquets. L'outil @command{guix environment} prend un ou plusieurs +paquets, construit leurs entrées et crée un environnement shell pour pouvoir +les utiliser. La syntaxe générale est : @example -guix environment @var{options} @var{package}@dots{} +guix environment @var{options} @var{paquet}@dots{} @end example -The following example spawns a new shell set up for the development of -GNU@tie{}Guile: +L'exemple suivant crée un nouveau shell préparé pour le développement de +GNU@tie{}Guile : @example guix environment guile @end example -If the needed dependencies are not built yet, @command{guix environment} -automatically builds them. The environment of the new shell is an augmented -version of the environment that @command{guix environment} was run in. It -contains the necessary search paths for building the given package added to -the existing environment variables. To create a ``pure'' environment, in -which the original environment variables have been unset, use the -@code{--pure} option@footnote{Users sometimes wrongfully augment environment -variables such as @code{PATH} in their @file{~/.bashrc} file. As a -consequence, when @code{guix environment} launches it, Bash may read -@file{~/.bashrc}, thereby introducing ``impurities'' in these environment -variables. It is an error to define such environment variables in -@file{.bashrc}; instead, they should be defined in @file{.bash_profile}, -which is sourced only by log-in shells. @xref{Bash Startup Files,,, bash, -The GNU Bash Reference Manual}, for details on Bash start-up files.}. +Si les dépendances requises ne sont pas déjà construites, @command{guix +environment} les construit automatiquement. L'environnement du nouveau +shell est une version améliorée de l'environnement dans lequel @command{guix +environment} a été lancé. Il contient les chemins de recherche nécessaires +à la construction du paquet donné en plus des variables d'environnement +existantes. Pour créer un environnement « pur », dans lequel les variables +d'environnement de départ ont été nettoyées, utilisez l'option +@code{--pure}@footnote{Les utilisateurs ajoutent parfois à tord des valeurs +supplémentaires dans les variables comme @code{PATH} dans leur +@file{~/.bashrc}. En conséquence, lorsque @code{guix environment} le lance, +Bash peut lire @file{~/.bashrc}, ce qui produit des « impuretés » dans ces +variables d'environnement. C'est une erreur de définir ces variables +d'environnement dans @file{.bashrc} ; à la place, elles devraient être +définie dans @file{.bash_profile}, qui est sourcé uniquement par les shells +de connexion. @xref{Bash Startup Files,,, bash, The GNU Bash Reference +Manual}, pour des détails sur les fichiers de démarrage de Bash.}. @vindex GUIX_ENVIRONMENT -@command{guix environment} defines the @code{GUIX_ENVIRONMENT} variable in -the shell it spawns; its value is the file name of the profile of this -environment. This allows users to, say, define a specific prompt for -development environments in their @file{.bashrc} (@pxref{Bash Startup -Files,,, bash, The GNU Bash Reference Manual}): +@command{guix environment} définie la variable @code{GUIX_ENVIRONMENT} dans +le shell qu'il crée ; sa valeur est le nom de fichier du profil de cet +environnement. Cela permet aux utilisateur, disons, de définir un prompt +spécifique pour les environnement de développement dans leur @file{.bashrc} +(@pxref{Bash Startup Files,,, bash, The GNU Bash Reference Manual}) : @example if [ -n "$GUIX_ENVIRONMENT" ] @@ -7498,119 +7759,119 @@ fi @end example @noindent -... or to browse the profile: +… ou de naviguer dans le profil : @example $ ls "$GUIX_ENVIRONMENT/bin" @end example -Additionally, more than one package may be specified, in which case the -union of the inputs for the given packages are used. For example, the -command below spawns a shell where all of the dependencies of both Guile and -Emacs are available: +En plus, plus d'un paquet peut être spécifié, auquel cas l'union des entrées +des paquets données est utilisée. Par exemple, la commande ci-dessous crée +un shell où toutes les dépendances de Guile et Emacs sont disponibles : @example guix environment guile emacs @end example -Sometimes an interactive shell session is not desired. An arbitrary command -may be invoked by placing the @code{--} token to separate the command from -the rest of the arguments: +Parfois, une session shell interactive est inutile. On peut invoquer une +commande arbitraire en plaçant le jeton @code{--} pour séparer la commande +du reste des arguments : @example guix environment guile -- make -j4 @end example -In other situations, it is more convenient to specify the list of packages -needed in the environment. For example, the following command runs -@command{python} from an environment containing Python@tie{}2.7 and NumPy: +Dans d'autres situations, il est plus pratique de spécifier la liste des +paquets requis dans l'environnement. Par exemple, la commande suivante +lance @command{python} dans un environnement contenant Python@tie{}2.7 et +NumPy : @example guix environment --ad-hoc python2-numpy python-2.7 -- python @end example -Furthermore, one might want the dependencies of a package and also some -additional packages that are not build-time or runtime dependencies, but are -useful when developing nonetheless. Because of this, the @code{--ad-hoc} -flag is positional. Packages appearing before @code{--ad-hoc} are -interpreted as packages whose dependencies will be added to the -environment. Packages appearing after are interpreted as packages that will -be added to the environment directly. For example, the following command -creates a Guix development environment that additionally includes Git and -strace: +En plus, on peut vouloir les dépendance d'un paquet et aussi des paquets +supplémentaires qui ne sont pas des dépendances à l'exécution ou à la +construction, mais qui sont utiles au développement tout de même. À cause +de cela, le drapeau @code{--ad-hoc} est positionnel. Les paquets qui +apparaissent avant @code{--ad-hoc} sont interprétés comme les paquets dont +les dépendances seront ajoutées à l'environnement. Les paquets qui +apparaissent après @code{--ad-hoc} sont interprétés comme les paquets à +ajouter à l'environnement directement. Par exemple, la commande suivante +crée un environnement de développement pour Guix avec les paquets Git et +strace en plus : @example guix environment guix --ad-hoc git strace @end example -Sometimes it is desirable to isolate the environment as much as possible, -for maximal purity and reproducibility. In particular, when using Guix on a -host distro that is not GuixSD, it is desirable to prevent access to -@file{/usr/bin} and other system-wide resources from the development -environment. For example, the following command spawns a Guile REPL in a -``container'' where only the store and the current working directory are -mounted: +Parfois il est souhaitable d'isoler l'environnement le plus possible, pour +une pureté et une reproductibilité maximale. En particulier, lorsque vous +utilisez Guix sur une distribution hôte qui n'est pas GuixSD, il est +souhaitable d'éviter l'accès à @file{/usr/bin} et d'autres ressources du +système depuis les environnements de développement. Par exemple, la +commande suivante crée un REPL Guile dans un « conteneur » où seuls le dépôt +et le répertoire de travail actuel sont montés : @example guix environment --ad-hoc --container guile -- guile @end example @quotation Remarque -The @code{--container} option requires Linux-libre 3.19 or newer. +L'option @code{--container} requiert Linux-libre 3.19 ou supérieur. @end quotation -The available options are summarized below. +Les options disponibles sont résumées ci-dessous. @table @code -@item --root=@var{file} -@itemx -r @var{file} -@cindex persistent environment -@cindex garbage collector root, for environments -Make @var{file} a symlink to the profile for this environment, and register -it as a garbage collector root. +@item --root=@var{fichier} +@itemx -r @var{fichier} +@cindex environnement persistent +@cindex racine du ramasse-miettes, pour les environnements +Fait de @var{fichier} un lien symbolique vers le profil de cet +environnement, et l'enregistre comme une racine du ramasse-miettes. -This is useful if you want to protect your environment from garbage -collection, to make it ``persistent''. +C'est utile si vous souhaitez protéger votre environnement du +ramasse-miettes, pour le rendre « persistent ». -When this option is omitted, the environment is protected from garbage -collection only for the duration of the @command{guix environment} session. -This means that next time you recreate the same environment, you could have -to rebuild or re-download packages. @xref{Invoquer guix gc}, for more on GC -roots. +Lorsque cette option est omise, l'environnement n'est protégé du +ramasse-miettes que le temps de la session @command{guix environment}. Cela +signifie que la prochaine fois que vous créerez le même environnement, vous +pourriez avoir à reconstruire ou télécharger des paquets. @xref{Invoquer guix gc}, pour plus d'informations sur les racines du GC. @item --expression=@var{expr} @itemx -e @var{expr} -Create an environment for the package or list of packages that @var{expr} -evaluates to. +Crée un environnement pour le paquet ou la liste de paquets en lesquels +s'évalue @var{expr}. -For example, running: +Par exemple, lancer : @example guix environment -e '(@@ (gnu packages maths) petsc-openmpi)' @end example -starts a shell with the environment for this specific variant of the PETSc -package. +démarre un shell avec l'environnement pour cette variante spécifique du +paquet PETSc. -Running: +Lancer : @example guix environment --ad-hoc -e '(@@ (gnu) %base-packages)' @end example -starts a shell with all the GuixSD base packages available. +démarre un shell où tous les paquets de base de GuixSD sont disponibles. -The above commands only use the default output of the given packages. To -select other outputs, two element tuples can be specified: +Les commande au-dessus n'utilisent que les sorties par défaut des paquets +donnés. Pour choisir d'autres sorties, on peut spécifier des pairs : @example guix environment --ad-hoc -e '(list (@@ (gnu packages bash) bash) "include")' @end example -@item --load=@var{file} -@itemx -l @var{file} -Create an environment for the package or list of packages that the code -within @var{file} evaluates to. +@item --load=@var{fichier} +@itemx -l @var{fichier} +Crée un environnement pour le paquet ou la liste de paquets en lesquels +@var{fichier} s'évalue. Par exemple, @var{fichier} peut contenir une définition comme celle-ci (@pxref{Définition des paquets}) : @@ -7621,152 +7882,159 @@ Par exemple, @var{fichier} peut contenir une définition comme celle-ci @item --manifest=@var{fichier} @itemx -m @var{fichier} -Create an environment for the packages contained in the manifest object -returned by the Scheme code in @var{file}. +Crée un environnement pour les paquets contenus dans l'objet manifeste +renvoyé par le code Scheme dans @var{fichier}. -This is similar to the same-named option in @command{guix package} -(@pxref{profile-manifest, @option{--manifest}}) and uses the same manifest -files. +C'est similaire à l'option de même nom de @command{guix package} +(@pxref{profile-manifest, @option{--manifest}}) et utilise les même fichiers +manifestes. @item --ad-hoc -Include all specified packages in the resulting environment, as if an @i{ad -hoc} package were defined with them as inputs. This option is useful for -quickly creating an environment without having to write a package expression -to contain the desired inputs. +Inclut tous les paquets spécifiés dans l'environnement qui en résulte, comme +si un paquet @i{ad hoc} était spécifié, avec ces paquets comme entrées. +Cette option est utile pour créer un environnement rapidement sans avoir à +écrire une expression de paquet contenant les entrées désirées. -For instance, the command: +Par exemple la commande : @example guix environment --ad-hoc guile guile-sdl -- guile @end example -runs @command{guile} in an environment where Guile and Guile-SDL are -available. +lance @command{guile} dans un environnement où Guile et Guile-SDDL sont +disponibles. -Note that this example implicitly asks for the default output of -@code{guile} and @code{guile-sdl}, but it is possible to ask for a specific -output---e.g., @code{glib:bin} asks for the @code{bin} output of @code{glib} -(@pxref{Des paquets avec plusieurs résultats}). +Remarquez que cet exemple demande implicitement la sortie par défaut de +@code{guile} et @code{guile-sdl}, mais il est possible de demander une +sortie spécifique — p.@: ex.@: @code{glib:bin} demande la sortie @code{bin} +de @code{glib} (@pxref{Des paquets avec plusieurs résultats}). -This option may be composed with the default behavior of @command{guix -environment}. Packages appearing before @code{--ad-hoc} are interpreted as -packages whose dependencies will be added to the environment, the default -behavior. Packages appearing after are interpreted as packages that will be -added to the environment directly. +Cette option peut être composée avec le comportement par défaut de +@command{guix environment}. Les paquets qui apparaissent avant +@code{--ad-hoc} sont interprétés comme les paquets dont les dépendances +seront ajoutées à l'environnement, le comportement par défaut. Les paquets +qui apparaissent après @code{--ad-hoc} sont interprétés comme les paquets à +ajouter à l'environnement directement. @item --pure -Unset existing environment variables when building the new environment. -This has the effect of creating an environment in which search paths only -contain package inputs. +Nettoie les variables d'environnement existantes lors de la construction du +nouvel environnement. Cela a pour effet de créer un environnement dans +lequel les chemins de recherche ne contiennent que des entrées de paquets. @item --search-paths -Display the environment variable definitions that make up the environment. +Affiche les définitions des variables d'environnement qui composent +l'environnement. @item --system=@var{système} @itemx -s @var{système} -Attempt to build for @var{system}---e.g., @code{i686-linux}. +Essaye de construire pour @var{système} — p.@: ex.@: @code{i686-linux}. @item --container @itemx -C -@cindex container -Run @var{command} within an isolated container. The current working -directory outside the container is mapped inside the container. -Additionally, unless overridden with @code{--user}, a dummy home directory -is created that matches the current user's home directory, and -@file{/etc/passwd} is configured accordingly. The spawned process runs as -the current user outside the container, but has root privileges in the -context of the container. +@cindex conteneur +Lance @var{commande} dans un conteneur isolé. Le répertoire de travail +actuel en dehors du conteneur est monté dans le conteneur. En plus, à moins +de le changer avec @code{--user}, un répertoire personnel fictif est créé +pour correspondre à celui de l'utilisateur actuel et @file{/etc/passwod} est +configuré en conséquence. Le processus est lancé en tant que l'utilisateur +actuel en dehors du conteneur, mais a les privilèges root dans le contexte +du conteneur. @item --network @itemx -N -For containers, share the network namespace with the host system. -Containers created without this flag only have access to the loopback -device. +Pour les conteneurs, partage l'espace de nom du réseau avec le système +hôte. Les conteneurs créés sans cette option n'ont accès qu'à l'interface +de boucle locale. @item --link-profile @itemx -P -For containers, link the environment profile to @file{~/.guix-profile} -within the container. This is equivalent to running the command @command{ln --s $GUIX_ENVIRONMENT ~/.guix-profile} within the container. Linking will -fail and abort the environment if the directory already exists, which will -certainly be the case if @command{guix environment} was invoked in the -user's home directory. +Pour les conteneurs, lie le profil de l'environnement à +@file{~/.guix-profile} dans le conteneur. C'est équivalent à lance la +commande @command{ln -s $GUIX_ENVIRONMENT ~/.guix-profile} dans le +conteneur. La liaison échouera et annulera l'environnement si le répertoire +existe déjà, ce qui sera sans doute le cas si @command{guix environment} est +invoqué dans le répertoire personnel de l'utilisateur. -Certain packages are configured to look in @code{~/.guix-profile} for -configuration files and data;@footnote{For example, the @code{fontconfig} -package inspects @file{~/.guix-profile/share/fonts} for additional fonts.} -@code{--link-profile} allows these programs to behave as expected within the -environment. +Certains paquets sont configurés pour chercher des fichiers de configuration +et des données dans @code{~/.guix-profile}@footnote{Par exemple, le paquet +@code{fontconfig} inspecte @file{~/.guix-profile/share/fonts} pour trouver +des polices supplémentaires.} ; @code{--link-profile} permet à ces +programmes de se comporter comme attendu dans l'environnement. -@item --user=@var{user} -@itemx -u @var{user} -For containers, use the username @var{user} in place of the current user. -The generated @file{/etc/passwd} entry within the container will contain the -name @var{user}; the home directory will be @file{/home/USER}; and no user -GECOS data will be copied. @var{user} need not exist on the system. +@item --user=@var{utilisateur} +@itemx -u @var{utilisateur} +Pour les conteneurs, utilise le nom d'utilisateur @var{utilisateur} à la +place de l'utilisateur actuel. L'entrée générée dans @file{/etc/passwod} +dans le conteneur contiendra le nom @var{utilisateur} ; le répertoire +personnel sera @file{/home/UTILISATEUR} ; et aucune donnée GECOS ne sera +copiée. @var{utilisateur} n'a pas besoin d'exister sur le système. -Additionally, any shared or exposed path (see @code{--share} and -@code{--expose} respectively) whose target is within the current user's home -directory will be remapped relative to @file{/home/USER}; this includes the -automatic mapping of the current working directory. +En plus, tous les chemins partagés ou exposés (voir @code{--share} et +@code{--expose} respectivement) dont la cible est dans le répertoire +personnel de l'utilisateur seront remontés relativement à +@file{/home/UTILISATEUR} ; cela comprend le montage automatique du +répertoire de travail actuel. @example -# will expose paths as /home/foo/wd, /home/foo/test, and /home/foo/target +# exposera les chemins comme /home/foo/wd, /home/foo/test et /home/foo/target cd $HOME/wd guix environment --container --user=foo \ --expose=$HOME/test \ --expose=/tmp/target=$HOME/target @end example -While this will limit the leaking of user identity through home paths and -each of the user fields, this is only one useful component of a broader -privacy/anonymity solution---not one in and of itself. +Bien que cela limite la fuite de l'identité de l'utilisateur à travers le +chemin du répertoire personnel et des champs de l'utilisateur, ce n'est +qu'un composant utile pour une solution d'anonymisation ou de préservation +de la vie privée — pas une solution en elle-même. -@item --expose=@var{source}[=@var{target}] -For containers, expose the file system @var{source} from the host system as -the read-only file system @var{target} within the container. If -@var{target} is not specified, @var{source} is used as the target mount -point in the container. +@item --expose=@var{source}[=@var{cible}] +Pour les conteneurs, expose le système de fichiers @var{source} du système +hôte comme un système de fichiers en lecture seule @var{cible} dans le +conteneur. Si @var{cible} n'est pas spécifiée, @var{source} est utilisé +comme point de montage dans le conteneur. -The example below spawns a Guile REPL in a container in which the user's -home directory is accessible read-only via the @file{/exchange} directory: +L'exemple ci-dessous crée un REPL Guile dans un conteneur dans lequel le +répertoire personnel de l'utilisateur est accessible en lecture-seule via le +répertoire @file{/exchange} : @example guix environment --container --expose=$HOME=/exchange --ad-hoc guile -- guile @end example -@item --share=@var{source}[=@var{target}] -For containers, share the file system @var{source} from the host system as -the writable file system @var{target} within the container. If @var{target} -is not specified, @var{source} is used as the target mount point in the -container. +@item --share=@var{source}[=@var{cible}] +Pour les conteneurs, partage le système de fichiers @var{soruce} du système +hôte comme un système de fichiers en lecture-écriture @var{cible} dans le +conteneur. Si @var{cible} n'est pas spécifiée, @var{source} est utilisée +comme point de montage dans le conteneur. -The example below spawns a Guile REPL in a container in which the user's -home directory is accessible for both reading and writing via the -@file{/exchange} directory: +L'exemple ci-dessous crée un REPL Guile dans un conteneur dans lequel le +répertoire personnel de l'utilisateur est accessible en lecture-écriture via +le répertoire @file{/exchange} : @example guix environment --container --share=$HOME=/exchange --ad-hoc guile -- guile @end example @end table -@command{guix environment} also supports all of the common build options -that @command{guix build} supports (@pxref{Options de construction communes}). +@command{guix environment} supporte aussi toutes les options de construction +que @command{guix build} supporte (@pxref{Options de construction communes}). @node Invoquer guix publish -@section Invoking @command{guix publish} +@section Invoquer @command{guix publish} @cindex @command{guix publish} Le but de @command{guix publish} est de vous permettre de partager facilement votre dépôt avec d'autres personnes qui peuvent ensuite l'utiliser comme serveur de substituts (@pxref{Substituts}). -When @command{guix publish} runs, it spawns an HTTP server which allows -anyone with network access to obtain substitutes from it. This means that -any machine running Guix can also act as if it were a build farm, since the -HTTP interface is compatible with Hydra, the software behind the -@code{hydra.gnu.org} build farm. +Lorsque @command{guix publish} est lancé, il crée un serveur HTTP qui permet +à n'importe qui avec un accès réseau d'y récupérer des substituts. Cela +signifie que toutes les machines qui font tourner Guix peuvent aussi agir +comme une ferme de construction, puisque l'interface HTTP est compatible +avec Hydra, le logiciel derrière la ferme de construction +@code{hydra.gnu.org}. Pour des raisons de sécurité, chaque substitut est signé, ce qui permet aux destinataires de vérifier leur authenticité et leur intégrité @@ -7775,8 +8043,9 @@ signature du système, qui n'est lisible que par l'administrateur système, il doit être lancé en root ; l'option @code{--user} lui fait baisser ses privilèges le plus tôt possible. -The signing key pair must be generated before @command{guix publish} is -launched, using @command{guix archive --generate-key} (@pxref{Invoquer guix archive}). +La pair de clefs pour les signatures doit être générée avant de lancer +@command{guix publish}, avec @command{guix archive --generate-key} +(@pxref{Invoquer guix archive}). La syntaxe générale est : @@ -7784,169 +8053,176 @@ La syntaxe générale est : guix publish @var{options}@dots{} @end example -Running @command{guix publish} without any additional arguments will spawn -an HTTP server on port 8080: +Lancer @command{guix publish} sans arguments supplémentaires lancera un +serveur HTTP sur le port 8080 : @example guix publish @end example -Once a publishing server has been authorized (@pxref{Invoquer guix archive}), the daemon may download substitutes from it: +Une fois qu'un serveur de publication a été autorisé (@pxref{Invoquer guix archive}), le démon peut télécharger des substituts à partir de lui : @example guix-daemon --substitute-urls=http://example.org:8080 @end example -By default, @command{guix publish} compresses archives on the fly as it -serves them. This ``on-the-fly'' mode is convenient in that it requires no -setup and is immediately available. However, when serving lots of clients, -we recommend using the @option{--cache} option, which enables caching of the -archives before they are sent to clients---see below for details. The -@command{guix weather} command provides a handy way to check what a server -provides (@pxref{Invoquer guix weather}). +Par défaut, @command{guix publish} compresse les archives à la volée quand +il les sert. Ce mode « à la volée » est pratique puisqu'il ne demande +aucune configuration et est disponible immédiatement. Cependant, lorsqu'il +s'agit de servir beaucoup de clients, nous recommandons d'utiliser l'option +@option{--cache}, qui active le cache des archives avant de les envoyer aux +clients — voir les détails plus bas. La commande @command{guix weather} +fournit un manière pratique de vérifier ce qu'un serveur fournit +(@pxref{Invoquer guix weather}). -As a bonus, @command{guix publish} also serves as a content-addressed mirror -for source files referenced in @code{origin} records (@pxref{Référence d'origine}). For instance, assuming @command{guix publish} is running on -@code{example.org}, the following URL returns the raw -@file{hello-2.10.tar.gz} file with the given SHA256 hash (represented in -@code{nix-base32} format, @pxref{Invoquer guix hash}): +En bonus, @command{guix publish} sert aussi un miroir adressé par le contenu +des fichiers source référencées dans les enregistrements @code{origin} +(@pxref{Référence d'origine}). Par exemple, en supposant que @command{guix +publish} tourne sur @code{example.org}, l'URL suivante renverra le fichie +brut @file{hello-2.10.tar.gz} avec le hash SHA256 donné (représenté sous le +format @code{nix-base32}, @pxref{Invoquer guix hash}) : @example http://example.org/file/hello-2.10.tar.gz/sha256/0ssi1@dots{}ndq1i @end example -Obviously, these URLs only work for files that are in the store; in other -cases, they return 404 (``Not Found''). +Évidemment, ces URL ne fonctionnent que pour des fichiers dans le dépôt ; +dans les autres cas, elles renvoie une erreur 404 (« Introuvable »). -@cindex build logs, publication -Build logs are available from @code{/log} URLs like: +@cindex journaux de construction, publication +Les journaux de construction sont disponibles à partir des URL @code{/log} +comme ceci : @example http://example.org/log/gwspk@dots{}-guile-2.2.3 @end example @noindent -When @command{guix-daemon} is configured to save compressed build logs, as -is the case by default (@pxref{Invoquer guix-daemon}), @code{/log} URLs -return the compressed log as-is, with an appropriate @code{Content-Type} -and/or @code{Content-Encoding} header. We recommend running -@command{guix-daemon} with @code{--log-compression=gzip} since Web browsers -can automatically decompress it, which is not the case with bzip2 -compression. +Lorsque @command{guix-daemon} est configuré pour sauvegarder les journaux de +construction compressés, comme c'est le cas par défaut (@pxref{Invoquer guix-daemon}), les URL @code{/log} renvoient le journal compressé tel-quel, +avec un en-tête @code{Content-Type} ou @code{Content-Encoding} approprié. +Nous recommandons de lancer @command{guix-daemon} avec +@code{--log-compression=gzip} pace que les navigateurs web les décompressent +automatiquement, ce qui n'est pas le cas avec la compression bzip2. -The following options are available: +Les options suivantes sont disponibles : @table @code @item --port=@var{port} @itemx -p @var{port} -Listen for HTTP requests on @var{port}. +Écoute les requêtes HTTP sur le @var{port} -@item --listen=@var{host} -Listen on the network interface for @var{host}. The default is to accept -connections from any interface. +@item --listen=@var{hôte} +Écoute sur l'interface réseau de @var{hôte}. Par défaut, la commande +accepte les connexions de n'importe quelle interface. -@item --user=@var{user} -@itemx -u @var{user} -Change privileges to @var{user} as soon as possible---i.e., once the server -socket is open and the signing key has been read. +@item --user=@var{utilisateur} +@itemx -u @var{utilisateur} +Charge les privilèges de @var{utilisateur} le plus vite possible — +c.-à-d. une fois que la socket du serveur est ouverte et que la clef de +signature a été lue. -@item --compression[=@var{level}] -@itemx -C [@var{level}] -Compress data using the given @var{level}. When @var{level} is zero, -disable compression. The range 1 to 9 corresponds to different gzip -compression levels: 1 is the fastest, and 9 is the best (CPU-intensive). -The default is 3. +@item --compression[=@var{niveau}] +@itemx -C [@var{niveau}] +Compresse les données au @var{niveau} donné. Lorsque le @var{niveau} est +zéro, désactive la compression. L'intervalle 1 à 9 correspond aux +différents niveaux de compression gzip : 1 est le plus rapide et 9 est la +meilleure (mais gourmande en CPU). Le niveau par défaut est 3. -Unless @option{--cache} is used, compression occurs on the fly and the -compressed streams are not cached. Thus, to reduce load on the machine that -runs @command{guix publish}, it may be a good idea to choose a low -compression level, to run @command{guix publish} behind a caching proxy, or -to use @option{--cache}. Using @option{--cache} has the advantage that it -allows @command{guix publish} to add @code{Content-Length} HTTP header to -its responses. +À moins que @option{--cache} ne soit utilisé, la compression se fait à la +volée et les flux compressés ne sont pas cachés. Ainsi, pour réduire la +charge sur la machine qui fait tourner @command{guix publish}, c'est une +bonne idée de choisir un niveau de compression faible, de lancer +@command{guix publish} derrière un serveur de cache ou d'utiliser +@option{--cache}. Utilise @option{--cache} a l'avantage qu'il permet à +@command{guix publish} d'ajouter l'en-tête HTTP @code{Content-Length} à sa +réponse. -@item --cache=@var{directory} -@itemx -c @var{directory} -Cache archives and meta-data (@code{.narinfo} URLs) to @var{directory} and -only serve archives that are in cache. +@item --cache=@var{répertoire} +@itemx -c @var{répertoire} +Cache les archives et les métadonnées (les URL @code{.narinfo}) dans +@var{répertoire} et ne sert que les archives dans ce cache. -When this option is omitted, archives and meta-data are created on-the-fly. -This can reduce the available bandwidth, especially when compression is -enabled, since this may become CPU-bound. Another drawback of the default -mode is that the length of archives is not known in advance, so -@command{guix publish} does not add a @code{Content-Length} HTTP header to -its responses, which in turn prevents clients from knowing the amount of -data being downloaded. +Lorsque cette option est omise, les archives et les métadonnées sont crées à +la volée. Cela réduit la bande passante disponible, surtout quand la +compression est activée puisqu'elle pourrait être limitée par le CPU. Un +autre inconvénient au mode par défaut est que la taille des archives n'est +pas connue à l'avance, donc @command{guix publish} n'ajoute pas l'en-tête +@code{Content-Length} à ses résponses, ce qui empêche les clients de savoir +la quantité de données à télécharger. -Conversely, when @option{--cache} is used, the first request for a store -item (@i{via} a @code{.narinfo} URL) returns 404 and triggers a background -process to @dfn{bake} the archive---computing its @code{.narinfo} and -compressing the archive, if needed. Once the archive is cached in -@var{directory}, subsequent requests succeed and are served directly from -the cache, which guarantees that clients get the best possible bandwidth. +À l'inverse, lorsque @option{--cache} est utilisée, la première requête pour +un élément du dépôt (via une URL @code{.narinfo}) renvoie une erreur 404 et +déclenche la création de l'archive — en calculant son @code{.narinfo} et en +compressant l'archive au besoin. Une fois l'archive cachée dans +@var{répertoire}, les requêtes suivantes réussissent et sont servies +directement depuis le cache, ce qui garanti que les clients ont la meilleure +bande passante possible. -The ``baking'' process is performed by worker threads. By default, one -thread per CPU core is created, but this can be customized. See -@option{--workers} below. +Le processus de création est effectué par des threads de travail. Par +défaut, un thread par cœur du CPU est créé, mais cela peut être +personnalisé. Voir @option{--workers} plus bas. -When @option{--ttl} is used, cached entries are automatically deleted when -they have expired. +Lorsque l'option @option{--ttl} est utilisée, les entrées cachées sont +automatiquement supprimées lorsqu'elles expirent. @item --workers=@var{N} -When @option{--cache} is used, request the allocation of @var{N} worker -threads to ``bake'' archives. +Lorsque @option{--cache} est utilisée, demande l'allocation de @var{N} +thread de travail pour créer les archives. @item --ttl=@var{ttl} -Produce @code{Cache-Control} HTTP headers that advertise a time-to-live -(TTL) of @var{ttl}. @var{ttl} must denote a duration: @code{5d} means 5 -days, @code{1m} means 1 month, and so on. +Produit des en-têtes HTTP @code{Cache-Control} qui expriment une durée de +vie (TTL) de @var{ttl}. @var{ttl} peut dénoter une durée : @code{5d} +signifie 5 jours, @code{1m} signifie un mois, etc. -This allows the user's Guix to keep substitute information in cache for -@var{ttl}. However, note that @code{guix publish} does not itself guarantee -that the store items it provides will indeed remain available for as long as -@var{ttl}. +Cela permet au Guix de l'utilisateur de garder les informations en cache +pendant @var{ttl}. Cependant, remarquez que @code{guix publish} ne garanti +pas lui-même que les éléments du dépôt qu'il fournit seront toujours +disponible pendant la durée @var{ttl}. -Additionally, when @option{--cache} is used, cached entries that have not -been accessed for @var{ttl} and that no longer have a corresponding item in -the store, may be deleted. +En plus, lorsque @option{--cache} est utilisée, les entrées cachées qui +n'ont pas été demandé depuis @var{ttl} et n'ont pas d'élément correspondant +dans le dépôt peuvent être supprimées. -@item --nar-path=@var{path} -Use @var{path} as the prefix for the URLs of ``nar'' files (@pxref{Invoquer guix archive, normalized archives}). +@item --nar-path=@var{chemin} +Utilise @var{chemin} comme préfixe des URL de fichier « nar » +(@pxref{Invoquer guix archive, normalized archives}). -By default, nars are served at a URL such as -@code{/nar/gzip/@dots{}-coreutils-8.25}. This option allows you to change -the @code{/nar} part to @var{path}. +Par défaut, les nars sont présents à l'URL comme +@code{/nar/gzip/@dots{}-coreutils-8.25}. Cette option vous permet de +changer la partie @code{/nar} en @var{chemin}. -@item --public-key=@var{file} -@itemx --private-key=@var{file} -Use the specific @var{file}s as the public/private key pair used to sign the -store items being published. +@item --public-key=@var{fichier} +@itemx --private-key=@var{fichier} +Utilise les @var{fichier}s spécifiques comme pair de clefs utilisées pour +signer les éléments avant de les publier. -The files must correspond to the same key pair (the private key is used for -signing and the public key is merely advertised in the signature metadata). -They must contain keys in the canonical s-expression format as produced by -@command{guix archive --generate-key} (@pxref{Invoquer guix archive}). By -default, @file{/etc/guix/signing-key.pub} and -@file{/etc/guix/signing-key.sec} are used. +Les fichiers doivent correspondre à la même pair de clefs (la clef privée +est utilisée pour signer et la clef publique est seulement ajouté aux +métadonnées de la signature). Ils doivent contenir les clefs dans le format +s-expression canonique produit par @command{guix archive --generate-key} +(@pxref{Invoquer guix archive}). Par défaut, +@file{/etc/guix/signing-key.pub} et @file{/etc/guix/signing-key.sec} sont +utilisés. @item --repl[=@var{port}] @itemx -r [@var{port}] -Spawn a Guile REPL server (@pxref{REPL Servers,,, guile, GNU Guile Reference -Manual}) on @var{port} (37146 by default). This is used primarily for -debugging a running @command{guix publish} server. +Crée un serveur REPL Guile (@pxref{REPL Servers,,, guile, GNU Guile +Reference Manual}) sur @var{pport} (37146 par défaut). C'est surtout utile +pour déboguer un serveur @command{guix publish} qui tourne. @end table -Enabling @command{guix publish} on a GuixSD system is a one-liner: just -instantiate a @code{guix-publish-service-type} service in the -@code{services} field of the @code{operating-system} declaration +Activer @command{guix publish} sur un système GuixSD est vraiment une seule +ligne : instantiez simplement un service @code{guix-publish-service-type} +dans le champs @code{services} de votre déclaration @code{operating-system} (@pxref{guix-publish-service-type, @code{guix-publish-service-type}}). -If you are instead running Guix on a ``foreign distro'', follow these -instructions:” +Si vous avez installé Guix sur une « distro extérieure », suivez ces +instructions : @itemize @item -If your host distro uses the systemd init system: +Si votre distro hôte utilise le système d'init systemd : @example # ln -s ~root/.guix-profile/lib/systemd/system/guix-publish.service \ @@ -7963,19 +8239,21 @@ Si votre distribution hôte utilise le système d'initialisation Upstart : @end example @item -Otherwise, proceed similarly with your distro's init system. +Sinon, procédez de manière similaire avec votre système d'init de votre +distro. @end itemize @node Invoquer guix challenge -@section Invoking @command{guix challenge} +@section Invoquer @command{guix challenge} @cindex constructions reproductibles -@cindex verifiable builds +@cindex constructions vérifiables @cindex @command{guix challenge} -@cindex challenge -Do the binaries provided by this server really correspond to the source code -it claims to build? Is a package build process deterministic? These are the -questions the @command{guix challenge} command attempts to answer. +@cindex défi +Est-ce que les binaires fournis par ce serveur correspondent réellement au +code source qu'il dit avoir construit ? Est-ce que le processus de +construction d'un paquet est déterministe ? Ce sont les question auxquelles +la commande @command{guix challenge} essaye de répondre. La première question est évidemment importante : avant d'utiliser un serveur de substituts (@pxref{Substituts}), il vaut mieux @emph{vérifier} qu'il @@ -7985,61 +8263,65 @@ alors des constructions indépendantes du paquet devraient donner le même résultat, bit à bit ; si un serveur fournit un binaire différent de celui obtenu localement, il peut être soit corrompu, soit malveillant. -We know that the hash that shows up in @file{/gnu/store} file names is the -hash of all the inputs of the process that built the file or -directory---compilers, libraries, build scripts, -etc. (@pxref{Introduction}). Assuming deterministic build processes, one -store file name should map to exactly one build output. @command{guix -challenge} checks whether there is, indeed, a single mapping by comparing -the build outputs of several independent builds of any given store item. +On sait que le hash qui apparaît dans @file{/gnu/store} est le hash de +toutes les entrées du processus qui construit le fichier ou le répertoire — +les compilateurs, les bibliothèques, les scripts de construction, +etc. (@pxref{Introduction}). En supposant que les processus de construction +sont déterministes, un nom de fichier dans le dépôt devrait correspondre +exactement à une sortie de construction. @command{guix challenge} vérifie +si il y a bien effectivement une seule correspondance en comparant les +sorties de plusieurs constructions indépendantes d'un élément du dépôt +donné. -The command output looks like this: +La sortie de la commande ressemble à : @smallexample $ guix challenge --substitute-urls="https://hydra.gnu.org https://guix.example.org" -updating list of substitutes from 'https://hydra.gnu.org'... 100.0% -updating list of substitutes from 'https://guix.example.org'... 100.0% -/gnu/store/@dots{}-openssl-1.0.2d contents differ: - local hash: 0725l22r5jnzazaacncwsvp9kgf42266ayyp814v7djxs7nk963q - https://hydra.gnu.org/nar/@dots{}-openssl-1.0.2d: 0725l22r5jnzazaacncwsvp9kgf42266ayyp814v7djxs7nk963q - https://guix.example.org/nar/@dots{}-openssl-1.0.2d: 1zy4fmaaqcnjrzzajkdn3f5gmjk754b43qkq47llbyak9z0qjyim -/gnu/store/@dots{}-git-2.5.0 contents differ: - local hash: 00p3bmryhjxrhpn2gxs2fy0a15lnip05l97205pgbk5ra395hyha - https://hydra.gnu.org/nar/@dots{}-git-2.5.0: 069nb85bv4d4a6slrwjdy8v1cn4cwspm3kdbmyb81d6zckj3nq9f - https://guix.example.org/nar/@dots{}-git-2.5.0: 0mdqa9w1p6cmli6976v4wi0sw9r4p5prkj7lzfd1877wk11c9c73 -/gnu/store/@dots{}-pius-2.1.1 contents differ: - local hash: 0k4v3m9z1zp8xzzizb7d8kjj72f9172xv078sq4wl73vnq9ig3ax - https://hydra.gnu.org/nar/@dots{}-pius-2.1.1: 0k4v3m9z1zp8xzzizb7d8kjj72f9172xv078sq4wl73vnq9ig3ax - https://guix.example.org/nar/@dots{}-pius-2.1.1: 1cy25x1a4fzq5rk0pmvc8xhwyffnqz95h2bpvqsz2mpvlbccy0gs +mise à jour de la liste des substituts depuis 'https://hydra.gnu.org'... 100.0% +mise à jour de la liste des substituts depuis 'https://guix.example.org'... 100.0% +le contenu de /gnu/store/@dots{}-openssl-1.0.2d diffère : + empreinte locale : 0725l22r5jnzazaacncwsvp9kgf42266ayyp814v7djxs7nk963q + https://hydra.gnu.org/nar/@dots{}-openssl-1.0.2d : 0725l22r5jnzazaacncwsvp9kgf42266ayyp814v7djxs7nk963q + https://guix.example.org/nar/@dots{}-openssl-1.0.2d : 1zy4fmaaqcnjrzzajkdn3f5gmjk754b43qkq47llbyak9z0qjyim +le contenu de /gnu/store/@dots{}-git-2.5.0 diffère : + empreinte locale : 00p3bmryhjxrhpn2gxs2fy0a15lnip05l97205pgbk5ra395hyha + https://hydra.gnu.org/nar/@dots{}-git-2.5.0 : 069nb85bv4d4a6slrwjdy8v1cn4cwspm3kdbmyb81d6zckj3nq9f + https://guix.example.org/nar/@dots{}-git-2.5.0 : 0mdqa9w1p6cmli6976v4wi0sw9r4p5prkj7lzfd1877wk11c9c73 +le contenu de /gnu/store/@dots{}-pius-2.1.1 diffère : + empreinte locale : 0k4v3m9z1zp8xzzizb7d8kjj72f9172xv078sq4wl73vnq9ig3ax + https://hydra.gnu.org/nar/@dots{}-pius-2.1.1 : 0k4v3m9z1zp8xzzizb7d8kjj72f9172xv078sq4wl73vnq9ig3ax + https://guix.example.org/nar/@dots{}-pius-2.1.1 : 1cy25x1a4fzq5rk0pmvc8xhwyffnqz95h2bpvqsz2mpvlbccy0gs @dots{} -6,406 store items were analyzed: - - 4,749 (74.1%) were identical - - 525 (8.2%) differed - - 1,132 (17.7%) were inconclusive +6,406 éléments du dépôt ont été analysés : + - 4,749 (74.1%) étaient identiques + - 525 (8.2%) étaient différents + - 1,132 (17.7%) étaient impossibles à évaluer @end smallexample @noindent -In this example, @command{guix challenge} first scans the store to determine -the set of locally-built derivations---as opposed to store items that were -downloaded from a substitute server---and then queries all the substitute -servers. It then reports those store items for which the servers obtained a -result different from the local build. +Dans cet exemple, @command{guix challenge} scanne d'abord le dépôt pour +déterminer l'ensemble des dérivations construites localement — en opposition +aux éléments qui ont été téléchargées depuis un serveur de substituts — puis +demande leur avis à tous les serveurs de substituts. Il rapporte ensuite +les éléments du dépôt pour lesquels les serveurs ont obtenu un résultat +différent de la construction locale. -@cindex non-determinism, in package builds -As an example, @code{guix.example.org} always gets a different answer. -Conversely, @code{hydra.gnu.org} agrees with local builds, except in the -case of Git. This might indicate that the build process of Git is -non-deterministic, meaning that its output varies as a function of various -things that Guix does not fully control, in spite of building packages in -isolated environments (@pxref{Fonctionnalités}). Most common sources of -non-determinism include the addition of timestamps in build results, the -inclusion of random numbers, and directory listings sorted by inode number. -See @uref{https://reproducible-builds.org/docs/}, for more information. +@cindex non-déterminisme, dans les constructions des paquets +Dans l'exemple, @code{guix.example.org} obtient toujours une réponse +différente. Inversement, @code{hydra.gnu.org} est d'accord avec les +constructions locale, sauf dans le cas de Git. Cela peut indiquer que le +processus de construction de Git est non-déterministe, ce qui signifie que +sa sortie diffère en fonction de divers choses que Guix ne contrôle pas +parfaitement, malgré l'isolation des constructions (@pxref{Fonctionnalités}). Les +sources les plus communes de non-déterminisme comprennent l'ajout +d'horodatage dans les résultats des constructions, l'inclusion de nombres +aléatoires et des listes de fichiers ordonnés par numéro d'inœud. Voir +@uref{https://reproducible-builds.org/docs/}, pour plus d'informations. -To find out what is wrong with this Git binary, we can do something along -these lines (@pxref{Invoquer guix archive}): +Pour trouver ce qui ne va pas avec le binaire de Git, on peut faire quelque +chose comme cela (@pxref{Invoquer guix archive}) : @example $ wget -q -O - https://hydra.gnu.org/nar/@dots{}-git-2.5.0 \ @@ -8047,96 +8329,102 @@ $ wget -q -O - https://hydra.gnu.org/nar/@dots{}-git-2.5.0 \ $ diff -ur --no-dereference /gnu/store/@dots{}-git.2.5.0 /tmp/git @end example -This command shows the difference between the files resulting from the local -build, and the files resulting from the build on @code{hydra.gnu.org} -(@pxref{Overview, Comparing and Merging Files,, diffutils, Comparing and -Merging Files}). The @command{diff} command works great for text files. -When binary files differ, a better option is @uref{https://diffoscope.org/, -Diffoscope}, a tool that helps visualize differences for all kinds of files. +Cette commande montre les différences entre les fichiers qui résultent de la +construction locale et des fichiers qui résultent de la construction sur +@code{hydra.gnu.org} (@pxref{Overview, Comparing and Merging Files,, +diffutils, Comparing and Merging Files}). La commande @command{diff} +fonctionne bien avec des fichiers texte. Lorsque des fichiers binaires +diffèrent cependant, @uref{https://diffoscope.org/, Diffoscope} est une +meilleure option. C'est un outil qui aide à visualiser les différences +entre toute sorte de fichiers. -Once you have done that work, you can tell whether the differences are due -to a non-deterministic build process or to a malicious server. We try hard -to remove sources of non-determinism in packages to make it easier to verify -substitutes, but of course, this is a process that involves not just Guix, -but a large part of the free software community. In the meantime, -@command{guix challenge} is one tool to help address the problem. +Une fois que vous avez fait ce travail, vous pourrez dire si les différences +sont dues au non-déterminisme du processus de construction ou à la +malhonnêteté du serveur. Nous avons fait beaucoup d'effort pour éliminer +les sources de non-déterminisme dans les paquets pour rendre plus facile la +vérification des substituts, mais bien sûr, c'est un processus qui +n'implique pas que Guix, mais une grande partie de la communauté des +logiciels libres. Pendant ce temps, @command{guix challenge} est un outil +pour aider à corriger le problème. -If you are writing packages for Guix, you are encouraged to check whether -@code{hydra.gnu.org} and other substitute servers obtain the same build -result as you did with: +Si vous écrivez un paquet pour Guix, nous vous encourageons à vérifier si +@code{hydra.gnu.org} et d'autres serveurs de substituts obtiennent le même +résultat que vous avec : @example -$ guix challenge @var{package} +$ guix challenge @var{paquet} @end example @noindent -where @var{package} is a package specification such as @code{guile@@2.0} or +où @var{paquet} est une spécification de paquet comme @code{guile@@2.0} ou @code{glibc:debug}. La syntaxe générale est : @example -guix challenge @var{options} [@var{packages}@dots{}] +guix challenge @var{options} [@var{paquets}@dots{}] @end example -When a difference is found between the hash of a locally-built item and that -of a server-provided substitute, or among substitutes provided by different -servers, the command displays it as in the example above and its exit code -is 2 (other non-zero exit codes denote other kinds of errors.) +Lorsqu'une différence est trouvée entre l'empreinte d'un élément construit +localement et celle d'un substitut fournit par un serveur, ou parmi les +substituts fournis par différents serveurs, la commande l'affiche comme dans +l'exemple ci-dessus et sa valeur de sortie est 2 (les autres valeurs +différentes de 0 indiquent d'autres sortes d'erreurs). -The one option that matters is: +L'option qui compte est : @table @code @item --substitute-urls=@var{urls} -Consider @var{urls} the whitespace-separated list of substitute source URLs -to compare to. +Considère @var{urls} comme la liste des URL des sources de substituts +séparés par des espaces avec lesquels comparer les paquets locaux. @item --verbose @itemx -v -Show details about matches (identical contents) in addition to information -about mismatches. +Montre des détails sur les correspondances (contenu identique) en plus des +informations sur différences. @end table @node Invoquer guix copy -@section Invoking @command{guix copy} +@section Invoquer @command{guix copy} -@cindex copy, of store items, over SSH -@cindex SSH, copy of store items -@cindex sharing store items across machines -@cindex transferring store items across machines -The @command{guix copy} command copies items from the store of one machine -to that of another machine over a secure shell (SSH) -connection@footnote{This command is available only when Guile-SSH was -found. @xref{Prérequis}, for details.}. For example, the following -command copies the @code{coreutils} package, the user's profile, and all -their dependencies over to @var{host}, logged in as @var{user}: +@cindex copier des éléments du dépôt par SSH +@cindex SSH, copie d'éléments du dépôt +@cindex partager des éléments du dépôt entre plusieurs machines +@cindex transférer des éléments du dépôt entre plusieurs machines +La commande @command{guix copy} copie des éléments du dépôt d'une machine +vers le dépôt d'une autre machine à travers une connexion SSH@footnote{Cette +commande n'est disponible que si Guile-SSH est trouvé. @xref{Prérequis}, +pour des détails}. Par exemple, la commande suivante copie le paquet +@code{coreutils}, le profil utilisateur et toutes leurs dépendances sur +@var{hôte}, en tant qu'utilisateur @var{utilisateur} : @example -guix copy --to=@var{user}@@@var{host} \ +guix copy --to=@var{utilisateur}@@@var{hôte} \ coreutils `readlink -f ~/.guix-profile` @end example -If some of the items to be copied are already present on @var{host}, they -are not actually sent. +Si certains éléments à copier sont déjà présents sur @var{hôte}, ils ne sont +pas envoyés. -The command below retrieves @code{libreoffice} and @code{gimp} from -@var{host}, assuming they are available there: +La commande ci-dessous récupère @code{libreoffice} et @code{gimp} depuis +@var{hôte}, en supposant qu'ils y sont présents : @example -guix copy --from=@var{host} libreoffice gimp +guix copy --from=@var{hôte} libreoffice gimp @end example -The SSH connection is established using the Guile-SSH client, which is -compatible with OpenSSH: it honors @file{~/.ssh/known_hosts} and -@file{~/.ssh/config}, and uses the SSH agent for authentication. +La connexion SSH est établie avec le client Guile-SSH, qui set compatible +avec OpenSSH : il honore @file{~/.ssh/known_hosts} et @file{~/.ssh/config} +et utilise l'agent SSH pour l'authentification. -The key used to sign items that are sent must be accepted by the remote -machine. Likewise, the key used by the remote machine to sign items you are -retrieving must be in @file{/etc/guix/acl} so it is accepted by your own -daemon. @xref{Invoquer guix archive}, for more information about store item -authentication. +La clef utilisée pour signer les éléments qui sont envoyés doit être +acceptée par la machine distante. De même, la clef utilisée pour la machine +distante depuis laquelle vous récupérez des éléments doit être dans +@file{/etc/guix/acl} pour qu'ils soient acceptés par votre propre démon. +@xref{Invoquer guix archive}, pour plus d'informations sur +l'authentification des éléments du dépôt. La syntaxe générale est : @@ -8144,36 +8432,38 @@ La syntaxe générale est : guix copy [--to=@var{spec}|--from=@var{spec}] @var{items}@dots{} @end example -You must always specify one of the following options: +Vous devez toujours spécifier l'une des options suivantes : @table @code @item --to=@var{spec} @itemx --from=@var{spec} -Specify the host to send to or receive from. @var{spec} must be an SSH spec -such as @code{example.org}, @code{charlie@@example.org}, or -@code{charlie@@example.org:2222}. +Spécifie l'hôte où envoyer ou d'où recevoir les éléments. @var{spec} doit +être une spécification SSH comme @code{example.org}, +@code{charlie@@example.org} ou @code{charlie@@example.org:2222}. @end table -The @var{items} can be either package names, such as @code{gimp}, or store -items, such as @file{/gnu/store/@dots{}-idutils-4.6}. +L'option @var{items} peut être des noms de paquets, comme @code{gimp} ou des +éléments du dépôt comme @file{/gnu/store/@dots{}-idutils-4.6}. -When specifying the name of a package to send, it is first built if needed, -unless @option{--dry-run} was specified. Common build options are supported -(@pxref{Options de construction communes}). +Lorsque vous spécifiez le nom d'un paquet à envoyer, il est d'abord +construit au besoin, sauf si l'option @option{--dry-run} est spécifiée. Les +options de construction communes sont supportées (@pxref{Options de construction communes}). @node Invoquer guix container -@section Invoking @command{guix container} -@cindex container +@section Invoquer @command{guix container} +@cindex conteneur @cindex @command{guix container} @quotation Remarque -As of version @value{VERSION}, this tool is experimental. The interface is -subject to radical change in the future. +À la version @value{VERSION}, cet outil est toujours expérimental. +L'interface est sujette à changement radicaux dans le futur. @end quotation -The purpose of @command{guix container} is to manipulate processes running -within an isolated environment, commonly known as a ``container'', typically -created by the @command{guix environment} (@pxref{Invoquer guix environment}) and @command{guix system container} (@pxref{Invoquer guix system}) commands. +Le but de @command{guix container} est de manipuler des processus qui +tournent dans un environnement séparé, connus sous le nom de « conteneur », +typiquement créés par les commandes @command{guix environment} +(@pxref{Invoquer guix environment}) et @command{guix system container} +(@pxref{Invoquer guix system}). La syntaxe générale est : @@ -8181,41 +8471,41 @@ La syntaxe générale est : guix container @var{action} @var{options}@dots{} @end example -@var{action} specifies the operation to perform with a container, and -@var{options} specifies the context-specific arguments for the action. +@var{action} spécifie les opérations à effectuer avec un conteneur, et +@var{options} spécifie les arguments spécifiques au contexte pour l'action. -The following actions are available: +Les actions suivantes sont disponibles : @table @code @item exec -Execute a command within the context of a running container. +Exécute une commande dans le contexte d'un conteneur lancé. -The syntax is: +La syntaxe est : @example -guix container exec @var{pid} @var{program} @var{arguments}@dots{} +guix container exec @var{pid} @var{programme} @var{arguments}@dots{} @end example -@var{pid} specifies the process ID of the running container. @var{program} -specifies an executable file name within the root file system of the -container. @var{arguments} are the additional options that will be passed -to @var{program}. +@var{pid} spécifie le PID du conteneur lancé. @var{programme} spécifie le +nom du fichier exécutable dans le système de fichiers racine du conteneur. +@var{arguments} sont les options supplémentairesà passer à @var{programme}. -The following command launches an interactive login shell inside a GuixSD -container, started by @command{guix system container}, and whose process ID -is 9001: +La commande suivante lance un shell de connexion interactif dans un +conteneur GuixSD, démarré par @command{guix system container} et dont le PID +est 9001 : @example guix container exec 9001 /run/current-system/profile/bin/bash --login @end example -Note that the @var{pid} cannot be the parent process of a container. It -must be PID 1 of the container or one of its child processes. +Remarquez que @var{pid} ne peut pas être le processus parent d'un +conteneur. Ce doit être le PID 1 du conteneur ou l'un de ses processus +fils. @end table @node Invoquer guix weather -@section Invoking @command{guix weather} +@section Invoquer @command{guix weather} Vous pouvez parfois grogner lorsque les substituts ne sont pas disponibles et que vous devez construire les paquets vous-même (@pxref{Substituts}). La @@ -8225,70 +8515,73 @@ aujourd'hui. Cela peut parfois être une information utile pour les utilisateurs, mais elle est surtout utile pour les personnes qui font tourner @command{guix publish} (@pxref{Invoquer guix publish}). -@cindex statistics, for substitutes -@cindex availability of substitutes -@cindex substitute availability -@cindex weather, substitute availability -Here's a sample run: +@cindex statistiques sur les substituts +@cindex disponibilité des substituts +@cindex substuts, disponibilité +@cindex weather, disponibilité des substituts +Voici un exemple : @example $ guix weather --substitute-urls=https://guix.example.org -computing 5,872 package derivations for x86_64-linux... -looking for 6,128 store items on https://guix.example.org.. -updating list of substitutes from 'https://guix.example.org'... 100.0% +calcul de 5,872 dérivations de paquets pour x86_64-linux… +recherche de 6,128 éléments du dépôt sur https://guix.example.org… +mise à jour de la liste des substituts depuis 'https://guix.example.org'... 100.0% https://guix.example.org - 43.4% substitutes available (2,658 out of 6,128) - 7,032.5 MiB of nars (compressed) - 19,824.2 MiB on disk (uncompressed) - 0.030 seconds per request (182.9 seconds in total) - 33.5 requests per second + 43.4% substituts disponibles (2,658 sur 6,128) + 7,032.5 Mo de fichiers nar (compressés) + 19,824.2 Mo sur le disque (décompressés) + 0.030 secondes par requêtes (182.9 secondes au total) + 33.5 requêtes par seconde - 9.8% (342 out of 3,470) of the missing items are queued - 867 queued builds - x86_64-linux: 518 (59.7%) - i686-linux: 221 (25.5%) - aarch64-linux: 128 (14.8%) - build rate: 23.41 builds per hour - x86_64-linux: 11.16 builds per hour - i686-linux: 6.03 builds per hour - aarch64-linux: 6.41 builds per hour + 9.8% (342 sur 3,470) des éléments manquants sont dans la queue + 867 constructions dans la queue + x86_64-linux : 518 (59.7%) + i686-linux : 221 (25.5%) + aarch64-linux : 128 (14.8%) + vitesse de construction : 23.41 constructions par heure + x86_64-linux : 11.16 constructions par heure + i686-linux : 6.03 constructions par heure + aarch64-linux : 6.41 constructions par heure @end example -@cindex continuous integration, statistics -As you can see, it reports the fraction of all the packages for which -substitutes are available on the server---regardless of whether substitutes -are enabled, and regardless of whether this server's signing key is -authorized. It also reports the size of the compressed archives (``nars'') -provided by the server, the size the corresponding store items occupy in the -store (assuming deduplication is turned off), and the server's throughput. -The second part gives continuous integration (CI) statistics, if the server -supports it. +@cindex intégration continue, statistiques +Comme vous pouvez le voir, elle rapporte le pourcentage des paquets pour +lesquels des substituts sont disponibles sur le serveur — indépendamment du +fait que les substituts soient activés, et indépendamment du fait que la +clef de signature du serveur soit autorisée. Elle rapporte aussi la taille +des archives compressées fournies par le serveur, la taille des éléments du +dépôt correspondant dans le dépôt (en supposant que la déduplication soit +désactivée) et la vitesse du serveur. La deuxième partie donne des +statistiques sur l'intégration continue (CI), si le serveur le supporte. -To achieve that, @command{guix weather} queries over HTTP(S) meta-data -(@dfn{narinfos}) for all the relevant store items. Like @command{guix -challenge}, it ignores signatures on those substitutes, which is innocuous -since the command only gathers statistics and cannot install those -substitutes. +Pour cela, @command{guix weather} récupère par HTTP(S) les métadonnées +(@dfn{narinfos}@ de tous les éléments du dépôts pertinents. Comme +@command{guix challenge}, il ignore les signatures de ces substituts, ce qui +n'est pas dangereux puisque la commande ne fait que récupérer des +statistiques et n'installe pas ces substituts. -Among other things, it is possible to query specific system types and -specific package sets. The available options are listed below. +Entre autres choses, il est possible de demander des types de système +particuliers et des ensembles de paquets particuliers. Les options +disponibles sont listées plus bas. @table @code @item --substitute-urls=@var{urls} -@var{urls} is the space-separated list of substitute server URLs to query. -When this option is omitted, the default set of substitute servers is -queried. +@var{urls} est la liste des URL des serveurs de substituts séparés par des +espaces. Lorsque cette option n'est pas renseignée, l'ensemble des serveurs +de substituts par défaut est utilisé. @item --system=@var{système} @itemx -s @var{système} -Query substitutes for @var{system}---e.g., @code{aarch64-linux}. This -option can be repeated, in which case @command{guix weather} will query -substitutes for several system types. +Effectue des requêtes pour les substituts @var{système} — p.@: ex.@: +@code{aarch64-linux}. Cette option peut être répétée, auquel cas +@command{guix weather} demandera les substituts de plusieurs types de +systèmes. @item --manifest=@var{fichier} -Instead of querying substitutes for all the packages, only ask for those -specified in @var{file}. @var{file} must contain a @dfn{manifest}, as with -the @code{-m} option of @command{guix package} (@pxref{Invoquer guix package}). +Plutôt que de demander des substituts pour tous les paquets, demande +uniquement les paquets spécifiés dans @var{fichier}. @var{fichier} doit +contenir un @dfn{manifeste} comme avec l'option @code{-m} de @command{guix +package} (@pxref{Invoquer guix package}). @end table @@ -8298,14 +8591,14 @@ the @code{-m} option of @command{guix package} (@pxref{Invoquer guix package}). @cindex Distribution Système Guix @cindex GuixSD -Guix comes with a distribution of the GNU system consisting entirely of free -software@footnote{The term ``free'' here refers to the -@url{http://www.gnu.org/philosophy/free-sw.html,freedom provided to users of -that software}.}. The distribution can be installed on its own -(@pxref{Installation du système}), but it is also possible to install Guix as a -package manager on top of an installed GNU/Linux system -(@pxref{Installation}). To distinguish between the two, we refer to the -standalone distribution as the Guix System Distribution, or GuixSD. +Guix fournit aussi une distribution du système GNU contenant uniquement des +logiciels libres@footnote{Le terme « libre » se réfère ici bien sûr à +@url{http://www.gnu.org/philosophy/free-sw.fr.html,la liberté offerte à +l'utilisateur de ces logiciels}.}. On peut installer la distribution +elle-même (@pxref{Installation du système}), mais on peut aussi installer Guix +comme gestionnaire de paquets par dessus un système GNU/Linux déjà installé +(@pxref{Installation}). Pour distinguer ces deux cas, on appelle la +distribution autonome « Distribution Système Guix » ou GuixSD. The distribution provides core GNU packages such as GNU libc, GCC, and Binutils, as well as many GNU and non-GNU applications. The complete list @@ -8434,7 +8727,7 @@ More and more system services are provided (@pxref{Services}), but some may be missing. @item -More than 6,500 packages are available, but you might occasionally find that +More than 7,500 packages are available, but you might occasionally find that a useful package is missing. @item @@ -8487,7 +8780,7 @@ their support in GNU/Linux. An ISO-9660 installation image that can be written to a USB stick or burnt to a DVD can be downloaded from -@indicateurl{ftp://alpha.gnu.org/gnu/guix/guixsd-install-@value{VERSION}.@var{system}.iso.xz}, +@indicateurl{https://alpha.gnu.org/gnu/guix/guixsd-install-@value{VERSION}.@var{system}.iso.xz}, where @var{system} is one of: @table @code @@ -8503,7 +8796,7 @@ Make sure to download the associated @file{.sig} file and to verify the authenticity of the image against it, along these lines: @example -$ wget ftp://alpha.gnu.org/gnu/guix/guixsd-install-@value{VERSION}.@var{system}.iso.xz.sig +$ wget https://alpha.gnu.org/gnu/guix/guixsd-install-@value{VERSION}.@var{system}.iso.xz.sig $ gpg --verify guixsd-install-@value{VERSION}.@var{system}.iso.xz.sig @end example @@ -8739,25 +9032,36 @@ Partition} (ESP) is required. This partition should be mounted at parted /dev/sda set 1 esp on @end example +@quotation Remarque +@vindex grub-bootloader +@vindex grub-efi-bootloader +Unsure whether to use EFI- or BIOS-based GRUB? If the directory +@file{/sys/firmware/efi} exists in the installation image, then you should +probably perform an EFI installation, using @code{grub-efi-bootloader}. +Otherwise you should use the BIOS-based GRUB, known as +@code{grub-bootloader}. @xref{Configuration du chargeur d'amorçage}, for more info on +bootloaders. +@end quotation + Once you are done partitioning the target hard disk drive, you have to create a file system on the relevant partition(s)@footnote{Currently GuixSD only supports ext4 and btrfs file systems. In particular, code that reads file system UUIDs and labels only works for these file system types.}. For -the ESP, if you have one and assuming it is @file{/dev/sda2}, run: +the ESP, if you have one and assuming it is @file{/dev/sda1}, run: @example -mkfs.fat -F32 /dev/sda2 +mkfs.fat -F32 /dev/sda1 @end example Preferably, assign file systems a label so that you can easily and reliably refer to them in @code{file-system} declarations (@pxref{Systèmes de fichiers}). This is typically done using the @code{-L} option of @command{mkfs.ext4} and related commands. So, assuming the target root partition lives at -@file{/dev/sda1}, a file system with the label @code{my-root} can be created +@file{/dev/sda2}, a file system with the label @code{my-root} can be created with: @example -mkfs.ext4 -L my-root /dev/sda1 +mkfs.ext4 -L my-root /dev/sda2 @end example @cindex encrypted disk @@ -8765,12 +9069,12 @@ If you are instead planning to encrypt the root partition, you can use the Cryptsetup/LUKS utilities to do that (see @inlinefmtifelse{html, @uref{https://linux.die.net/man/8/cryptsetup, @code{man cryptsetup}}, @code{man cryptsetup}} for more information.) Assuming you want to store -the root partition on @file{/dev/sda1}, the command sequence would be along +the root partition on @file{/dev/sda2}, the command sequence would be along these lines: @example -cryptsetup luksFormat /dev/sda1 -cryptsetup open --type luks /dev/sda1 my-partition +cryptsetup luksFormat /dev/sda2 +cryptsetup open --type luks /dev/sda2 my-partition mkfs.ext4 -L my-root /dev/mapper/my-partition @end example @@ -8790,11 +9094,11 @@ system init} afterwards. Finally, if you plan to use one or more swap partitions (@pxref{Memory Concepts, swap space,, libc, The GNU C Library Reference Manual}), make sure to initialize them with @command{mkswap}. Assuming you have one swap -partition on @file{/dev/sda2}, you would run: +partition on @file{/dev/sda3}, you would run: @example -mkswap /dev/sda2 -swapon /dev/sda2 +mkswap /dev/sda3 +swapon /dev/sda3 @end example Alternatively, you may use a swap file. For example, assuming that in the @@ -9068,6 +9372,28 @@ Below we discuss the effect of some of the most important fields fields), and how to @dfn{instantiate} the operating system using @command{guix system}. +@unnumberedsubsubsec Bootloader + +@cindex legacy boot, on Intel machines +@cindex BIOS boot, on Intel machines +@cindex UEFI boot +@cindex EFI boot +The @code{bootloader} field describes the method that will be used to boot +your system. Machines based on Intel processors can boot in ``legacy'' BIOS +mode, as in the example above. However, more recent machines rely instead +on the @dfn{Unified Extensible Firmware Interface} (UEFI) to boot. In that +case, the @code{bootloader} field should contain something along these +lines: + +@example +(bootloader-configuration + (bootloader grub-efi-bootloader) + (target "/boot/efi")) +@end example + +@xref{Configuration du chargeur d'amorçage}, for more information on the available +configuration options. + @unnumberedsubsubsec Globally-Visible Packages @vindex %base-packages @@ -9173,9 +9499,8 @@ this: @include os-config-desktop.texi @end lisp -@cindex UEFI -A graphical UEFI system with a choice of lightweight window managers instead -of full-blown desktop environments would look like this: +A graphical system with a choice of lightweight window managers instead of +full-blown desktop environments would look like this: @lisp @include os-config-lightweight-desktop.texi @@ -10007,7 +10332,7 @@ core services, that may be used in an @code{operating-system} declaration. * Services VPN:: Démons VPN * Système de fichiers en réseau:: Services liés à NFS@. * Intégration continue:: Le service Cuirass. -* Services de gestion de l'énergie:: L'outil TLP@. +* Power Management Services:: Extending battery life. * Services audio:: MPD@. * Services de virtualisation:: Services de virtualisation. * Services de contrôle de version:: Fournit des accès distants à des @@ -10836,6 +11161,21 @@ job definitions that are passed to mcron (@pxref{G-Expressions}). more information on mcron job specifications. Below is the reference of the mcron service. +On a running system, you can use the @code{schedule} action of the service +to visualize the mcron jobs that will be executed next: + +@example +# herd schedule mcron +@end example + +@noindent +The example above lists the next five tasks that will be executed, but you +can also specify the number of tasks to display: + +@example +# herd schedule mcron 10 +@end example + @deffn {Scheme Procedure} mcron-service @var{jobs} [#:mcron @var{mcron}] Return an mcron service running @var{mcron} that schedules @var{jobs}, a list of gexps denoting mcron job specifications. @@ -11035,7 +11375,7 @@ This is the type for statically-configured network interfaces. @end defvr @deffn {Scheme Procedure} static-networking-service @var{interface} @var{ip} @ - [#:netmask #f] [#:gateway #f] [#:name-servers @code{'()}] [#:requirement + [#:netmask #f] [#:gateway #f] [#:name-servers @code{'()}] @ [#:requirement @code{'(udev)}] Return a service that starts @var{interface} with address @var{ip}. If @var{netmask} is true, use it as the network mask. If @var{gateway} is true, it must be a string specifying the default network @@ -11534,6 +11874,15 @@ used only by protocol version 2. When true, forwarding of X11 graphical client connections is enabled---in other words, @command{ssh} options @option{-X} and @option{-Y} will work. +@item @code{allow-agent-forwarding?} (default: @code{#t}) +Whether to allow agent forwarding. + +@item @code{allow-tcp-forwarding?} (default: @code{#t}) +Whether to allow TCP forwarding. + +@item @code{gateway-ports?} (default: @code{#f}) +Whether to allow gateway ports. + @item @code{challenge-response-authentication?} (default: @code{#f}) Specifies whether challenge response authentication is allowed (e.g. via PAM). @@ -12033,17 +12382,21 @@ connections to the print server. Suppose you want to enable the Web interface of CUPS and also add support for Epson printers @i{via} the @code{escpr} package and for HP printers -@i{via} the @code{hplip} package. You can do that directly, like this (you -need to use the @code{(gnu packages cups)} module): +@i{via} the @code{hplip-minimal} package. You can do that directly, like +this (you need to use the @code{(gnu packages cups)} module): @example (service cups-service-type (cups-configuration (web-interface? #t) (extensions - (list cups-filters escpr hplip)))) + (list cups-filters escpr hplip-minimal)))) @end example +Note: If you wish to use the Qt5 based GUI which comes with the hplip +package then it is suggested that you install the @code{hplip} package, +either in your OS configuration file or as your user. + The available configuration parameters follow. Each parameter definition is preceded by its type; for example, @samp{string-list foo} indicates that the @code{foo} parameter should be specified as a list of strings. There is @@ -13135,13 +13488,14 @@ Users need to be in the @code{lp} group to access the D-Bus service. @cindex ALSA @cindex PulseAudio, sound support -The @code{(gnu services sound)} module provides an @code{alsa-service-type} -service to generate an ALSA @file{/etc/asound.conf} configuration file. -This configuration file is what allows applications that produce sound using -ALSA to be correctly handled. +The @code{(gnu services sound)} module provides a service to configure the +Advanced Linux Sound Architecture (ALSA) system, which making PulseAudio the +prefered ALSA output driver. @deffn {Variable Scheme} alsa-service-type -This is the type for the @uref{https://alsa-project.org/, ALSA}, +This is the type for the @uref{https://alsa-project.org/, Advanced Linux +Sound Architecture} (ALSA) system, which generates the +@file{/etc/asound.conf} configuration file. The value for this type is a @command{alsa-configuration} record as in this example: @example @@ -13155,6 +13509,9 @@ See below for details about @code{alsa-configuration}. Data type representing the configuration for @code{alsa-service}. @table @asis +@item @code{alsa-plugins} (default: @var{alsa-plugins}) +@code{alsa-plugins} package to use. + @item @code{pulseaudio?} (par défaut : @code{#t}) Whether ALSA applications should transparently be made to use the @uref{http://www.pulseaudio.org/, PulseAudio} sound server. @@ -13164,11 +13521,47 @@ the same time and to individual control them @i{via} @command{pavucontrol}, among other things. @item @code{extra-options} (par défaut : @code{""}) -String to append to the @file{asound.conf} file. +String to append to the @file{/etc/asound.conf} file. @end table @end deftp +Individual users who want to override the system configuration of ALSA can +do it with the @file{~/.asoundrc} file: + +@example +# In guix, we have to specify the absolute path for plugins. +pcm_type.jack @{ + lib "/home/alice/.guix-profile/lib/alsa-lib/libasound_module_pcm_jack.so" +@} + +# Routing ALSA to jack: +# . +pcm.rawjack @{ + type jack + playback_ports @{ + 0 system:playback_1 + 1 system:playback_2 + @} + + capture_ports @{ + 0 system:capture_1 + 1 system:capture_2 + @} +@} + +pcm.!default @{ + type plug + slave @{ + pcm "rawjack" + @} +@} +@end example + +See @uref{https://www.alsa-project.org/main/index.php/Asoundrc} for the +details. + + @node Services de bases de données @subsubsection Services de bases de données @@ -15467,6 +15860,39 @@ is accessed via a reverse proxy. @end table @end deftp +@subsubheading Prometheus Node Exporter Service + +@cindex prometheus-node-exporter +The Prometheus ``node exporter'' makes hardware and operating system +statistics provided by the Linux kernel available for the Prometheus +monitoring system. This service should be deployed on all physical nodes +and virtual machines, where monitoring these statistics is desirable. + +@defvar {Scheme variable} prometheus-node-exporter-service-type +This is the service type for the +@uref{https://github.com/prometheus/node_exporter/, +prometheus-node-exporter} service, its value must be a +@code{prometheus-node-exporter-configuration} record as in this example: + +@example +(service prometheus-node-exporter-service-type + (prometheus-node-exporter-configuration + (web-listen-address ":9100"))) +@end example +@end defvar + +@deftp {Data Type} prometheus-node-exporter-configuration +Data type representing the configuration of @command{node_exporter}. + +@table @asis +@item @code{package} (default: @code{go-github-com-prometheus-node-exporter}) +The prometheus-node-exporter package to use. + +@item @code{web-listen-address} (default: @code{":9100"}) +Bind the web interface to the specified address. + +@end table +@end deftp @node Services Kerberos @subsubsection Services Kerberos @@ -17320,9 +17746,9 @@ The local NFSv4 domain name. This must be a string or @code{#f}. If it is @subsubsection Intégration continue @cindex continuous integration -@uref{https://notabug.org/mthl/cuirass, Cuirass} est un outil d'intégration -continue pour Guix. On peut l'utiliser aussi bien pour le développement que -pour fournir des substituts à d'autres (@pxref{Substituts}). +@uref{https://git.savannah.gnu.org/cgit/guix/guix-cuirass.git, Cuirass} is a +continuous integration tool for Guix. It can be used both for development +and for providing substitutes to others (@pxref{Substituts}). The @code{(gnu services cuirass)} module provides the following service. @@ -17381,7 +17807,7 @@ added specifications. @item @code{port} (default: @code{8081}) Port number used by the HTTP server. -@item --listen=@var{host} +@item --listen=@var{hôte} Listen on the network interface for @var{host}. The default is to accept connections from localhost. @@ -17402,19 +17828,18 @@ Only evaluate specifications and build derivations once. When substituting a pre-built binary fails, fall back to building packages locally. -@item @code{load-path} (default: @code{'()}) -This allows users to define their own packages and make them visible to -cuirass as in @command{guix build} command. - @item @code{cuirass} (default: @code{cuirass}) The Cuirass package to use. @end table @end deftp -@node Services de gestion de l'énergie -@subsubsection Services de gestion de l'énergie +@node Power Management Services +@subsubsection Power Management Services +@cindex tlp @cindex power management with TLP +@subsubheading TLP daemon + The @code{(gnu services pm)} module provides a Guix service definition for the Linux power management tool TLP. @@ -17911,6 +18336,9 @@ Defaults to @samp{#f}. @end deftypevr +@cindex thermald +@cindex CPU frequency scaling with thermald +@subsubheading Thermald daemon The @code{(gnu services pm)} module provides an interface to thermald, a CPU frequency scaling service which helps prevent overheating. @@ -19662,51 +20090,51 @@ Defaults to @samp{""}. @end deftypevr -@deftypevr {@code{repository-cgit-configuration} parameter} repo-boolean enable-commit-graph? +@deftypevr {@code{repository-cgit-configuration} parameter} maybe-repo-boolean enable-commit-graph? A flag which can be used to disable the global setting @code{enable-commit-graph?}. -Defaults to @samp{#f}. +Defaults to @samp{disabled}. @end deftypevr -@deftypevr {@code{repository-cgit-configuration} parameter} repo-boolean enable-log-filecount? +@deftypevr {@code{repository-cgit-configuration} parameter} maybe-repo-boolean enable-log-filecount? A flag which can be used to disable the global setting @code{enable-log-filecount?}. -Defaults to @samp{#f}. +Defaults to @samp{disabled}. @end deftypevr -@deftypevr {@code{repository-cgit-configuration} parameter} repo-boolean enable-log-linecount? +@deftypevr {@code{repository-cgit-configuration} parameter} maybe-repo-boolean enable-log-linecount? A flag which can be used to disable the global setting @code{enable-log-linecount?}. -Defaults to @samp{#f}. +Defaults to @samp{disabled}. @end deftypevr -@deftypevr {@code{repository-cgit-configuration} parameter} repo-boolean enable-remote-branches? +@deftypevr {@code{repository-cgit-configuration} parameter} maybe-repo-boolean enable-remote-branches? Flag which, when set to @code{#t}, will make cgit display remote branches in the summary and refs views. -Defaults to @samp{#f}. +Defaults to @samp{disabled}. @end deftypevr -@deftypevr {@code{repository-cgit-configuration} parameter} repo-boolean enable-subject-links? +@deftypevr {@code{repository-cgit-configuration} parameter} maybe-repo-boolean enable-subject-links? A flag which can be used to override the global setting @code{enable-subject-links?}. -Defaults to @samp{#f}. +Defaults to @samp{disabled}. @end deftypevr -@deftypevr {@code{repository-cgit-configuration} parameter} repo-boolean enable-html-serving? +@deftypevr {@code{repository-cgit-configuration} parameter} maybe-repo-boolean enable-html-serving? A flag which can be used to override the global setting @code{enable-html-serving?}. -Defaults to @samp{#f}. +Defaults to @samp{disabled}. @end deftypevr @@ -20482,20 +20910,33 @@ The type of a bootloader configuration declaration. The bootloader to use, as a @code{bootloader} object. For now @code{grub-bootloader}, @code{grub-efi-bootloader}, @code{extlinux-bootloader} and @code{u-boot-bootloader} are supported. -@code{grub-efi-bootloader} allows to boot on modern systems using the -@dfn{Unified Extensible Firmware Interface} (UEFI). +@vindex grub-efi-bootloader +@code{grub-efi-bootloader} allows to boot on modern systems using the +@dfn{Unified Extensible Firmware Interface} (UEFI). This is what you should +use if the installation image contains a @file{/sys/firmware/efi} directory +when you boot it on your system. + +@vindex grub-bootloader +@code{grub-bootloader} allows you to boot in particular Intel-based machines +in ``legacy'' BIOS mode. + +@cindex ARM, bootloaders +@cindex AArch64, bootloaders Available bootloaders are described in @code{(gnu bootloader @dots{})} -modules. +modules. In particular, @code{(gnu bootloader u-boot)} contains definitions +of bootloaders for a wide range of ARM and AArch64 systems, using the +@uref{http://www.denx.de/wiki/U-Boot/, U-Boot bootloader}. @item @code{target} This is a string denoting the target onto which to install the bootloader. -The exact interpretation depends on the bootloader in question; for + +The interpretation depends on the bootloader in question. For @code{grub-bootloader}, for example, it should be a device name understood by the bootloader @command{installer} command, such as @code{/dev/sda} or -@code{(hd0)} (for GRUB, @pxref{Invoking grub-install,,, grub, GNU GRUB -Manual}). For @code{grub-efi-bootloader}, it should be the path to a -mounted EFI file system. +@code{(hd0)} (@pxref{Invoking grub-install,,, grub, GNU GRUB Manual}). For +@code{grub-efi-bootloader}, it should be the mount point of the EFI file +system, usually @file{/boot/efi}. @item @code{menu-entries} (default: @code{()}) A possibly empty list of @code{menu-entry} objects (see below), denoting @@ -20519,8 +20960,8 @@ The output terminals used for the bootloader boot menu, as a list of symbols. GRUB accepts the values: @code{console}, @code{serial}, @code{serial_@{0-3@}}, @code{gfxterm}, @code{vga_text}, @code{mda_text}, @code{morse}, and @code{pkmodem}. This field corresponds to the GRUB -variable GRUB_TERMINAL_OUTPUT (@pxref{Simple configuration,,, grub,GNU GRUB -manual}). +variable @code{GRUB_TERMINAL_OUTPUT} (@pxref{Simple configuration,,, +grub,GNU GRUB manual}). @item @code{terminal-inputs} (default: @code{'()}) The input terminals used for the bootloader boot menu, as a list of @@ -20528,7 +20969,8 @@ symbols. For GRUB, the default is the native platform terminal as determined at run-time. GRUB accepts the values: @code{console}, @code{serial}, @code{serial_@{0-3@}}, @code{at_keyboard}, and @code{usb_keyboard}. This field corresponds to the GRUB variable -GRUB_TERMINAL_INPUT (@pxref{Simple configuration,,, grub,GNU GRUB manual}). +@code{GRUB_TERMINAL_INPUT} (@pxref{Simple configuration,,, grub,GNU GRUB +manual}). @item @code{serial-unit} (default: @code{#f}) The serial unit used by the bootloader, as an integer from 0 to 3. For @@ -20860,7 +21302,7 @@ give the container additional permissions. For example, if you intend to build software using Guix inside of the Docker container, you may need to pass the @option{--privileged} option to @code{docker run}. -@item container +@item conteneur Return a script to run the operating system declared in @var{file} within a container. Containers are a set of lightweight isolation mechanisms provided by the kernel Linux-libre. Containers are substantially less @@ -20929,10 +21371,10 @@ When this option is omitted, @command{guix system} computes an estimate of the image size as a function of the size of the system declared in @var{file}. -@item --root=@var{file} -@itemx -r @var{file} -Make @var{file} a symlink to the result, and register it as a garbage -collector root. +@item --root=@var{fichier} +@itemx -r @var{fichier} +Fait de @var{fichier} un lien symbolique vers le résultat, et l'enregistre +en tant que racine du ramasse-miettes. @item --skip-checks Skip pre-installation safety checks. @@ -21028,7 +21470,7 @@ shepherd services of the operating system defined in @var{file}. @cindex virtual machine To run GuixSD in a virtual machine (VM), one can either use the pre-built GuixSD VM image distributed at -@indicateurl{ftp://alpha.gnu.org/guix/guixsd-vm-image-@value{VERSION}.@var{system}.tar.xz} +@indicateurl{https://alpha.gnu.org/gnu/guix/guixsd-vm-image-@value{VERSION}.@var{system}.xz} , or build their own virtual machine image using @command{guix system vm-image} (@pxref{Invoquer guix system}). The returned image is in qcow2 format, which the @uref{http://qemu.org/, QEMU emulator} can efficiently @@ -21608,6 +22050,17 @@ to start and stop processes (@pxref{Service De- and Constructors,,, shepherd, The GNU Shepherd Manual}). They are given as G-expressions that get expanded in the Shepherd configuration file (@pxref{G-Expressions}). +@item @code{actions} (default: @code{'()}) +@cindex actions, of Shepherd services +This is a list of @code{shepherd-action} objects (see below) defining +@dfn{actions} supported by the service, in addition to the standard +@code{start} and @code{stop} actions. Actions listed here become available +as @command{herd} sub-commands: + +@example +herd @var{action} @var{service} [@var{arguments}@dots{}] +@end example + @item @code{documentation} A documentation string, as shown when running: @@ -21625,6 +22078,55 @@ This is the list of modules that must be in scope when @code{start} and @end table @end deftp +@deftp {Data Type} shepherd-action +This is the data type that defines additional actions implemented by a +Shepherd service (see above). + +@table @code +@item name +Symbol naming the action. + +@item documentation +This is a documentation string for the action. It can be viewed by running: + +@example +herd doc @var{service} action @var{action} +@end example + +@item procedure +This should be a gexp that evaluates to a procedure of at least one +argument, which is the ``running value'' of the service (@pxref{Slots of +services,,, shepherd, The GNU Shepherd Manual}). +@end table + +The following example defines an action called @code{say-hello} that kindly +greets the user: + +@example +(shepherd-action + (name 'say-hello) + (documentation "Say hi!") + (procedure #~(lambda (running . args) + (format #t "Hello, friend! arguments: ~s\n" + args) + #t))) +@end example + +Assuming this action is added to the @code{example} service, then you can +do: + +@example +# herd say-hello example +Hello, friend! arguments: () +# herd say-hello example a b c +Hello, friend! arguments: ("a" "b" "c") +@end example + +This, as you can see, is a fairly sophisticated way to say hello. +@xref{Service Convenience,,, shepherd, The GNU Shepherd Manual}, for more +info on actions. +@end deftp + @defvr {Scheme Variable} shepherd-root-service-type The service type for the Shepherd ``root service''---i.e., PID@tie{}1. @@ -21768,7 +22270,7 @@ check whether a package has a @code{debug} output, use @command{guix package @section Mises à jour de sécurité @cindex security updates -@cindex security vulnerabilities +@cindex vulnérabilités Occasionally, important security vulnerabilities are discovered in software packages and must be patched. Guix developers try hard to keep track of known vulnerabilities and to apply fixes as soon as possible in the diff --git a/po/doc/guix-manual.fr.po b/po/doc/guix-manual.fr.po index e1df54e9ef..e539992c18 100644 --- a/po/doc/guix-manual.fr.po +++ b/po/doc/guix-manual.fr.po @@ -8,7 +8,7 @@ msgstr "" "Project-Id-Version: guix-manual 0.15.0\n" "Report-Msgid-Bugs-To: ludo@gnu.org\n" "POT-Creation-Date: 2018-06-22 14:12+0200\n" -"PO-Revision-Date: 2018-06-23 14:21+0200\n" +"PO-Revision-Date: 2018-08-15 18:07+0200\n" "Last-Translator: Julien Lepiller \n" "Language-Team: French \n" "Language: fr\n" @@ -9004,38 +9004,46 @@ msgstr "Comme on pourrait s'en douter, cette primitive est difficile à utiliser #. type: Plain text #: doc/guix.texi:4597 msgid "Once upon a time, @code{gexp->derivation} did not exist and constructing derivations with build code written in Scheme was achieved with @code{build-expression->derivation}, documented below. This procedure is now deprecated in favor of the much nicer @code{gexp->derivation}." -msgstr "" +msgstr "Il fut un temps où @code{gexp->derivation} n'existait pas et où construire une dérivation donc le code de construction était écrit en Scheme se faisait avec @code{build-expression->derivation}, documenté plus bas. Cette procédure est maintenant obsolète, remplacée par @code{gexp->derivation} qui est meilleure." #. type: deffn #: doc/guix.texi:4598 #, no-wrap msgid "{Scheme Procedure} build-expression->derivation @var{store} @" -msgstr "" +msgstr "{Procédure Scheme} build-expression->derivation @var{store} @" #. type: deffn #: doc/guix.texi:4614 msgid "@var{name} @var{exp} @ [#:system (%current-system)] [#:inputs '()] @ [#:outputs '(\"out\")] [#:hash #f] [#:hash-algo #f] @ [#:recursive? #f] [#:env-vars '()] [#:modules '()] @ [#:references-graphs #f] [#:allowed-references #f] @ [#:disallowed-references #f] @ [#:local-build? #f] [#:substitutable? #t] [#:guile-for-build #f] Return a derivation that executes Scheme expression @var{exp} as a builder for derivation @var{name}. @var{inputs} must be a list of @code{(name drv-path sub-drv)} tuples; when @var{sub-drv} is omitted, @code{\"out\"} is assumed. @var{modules} is a list of names of Guile modules from the current search path to be copied in the store, compiled, and made available in the load path during the execution of @var{exp}---e.g., @code{((guix build utils) (guix build gnu-build-system))}." msgstr "" +"@var{name} @var{exp} @\n" +"[#:system (%current-system)] [#:inputs '()] @\n" +"[#:outputs '(\"out\")] [#:hash #f] [#:hash-algo #f] @\n" +"[#:recursive? #f] [#:env-vars '()] [#:modules '()] @\n" +"[#:references-graphs #f] [#:allowed-references #f] @\n" +"[#:disallowed-references #f] @\n" +"[#:local-build? #f] [#:substitutable? #t] [#:guile-for-build #f]\n" +"Renvoie une dérivation qui exécute l'expression Scheme @var{exp} comme un constructeur pour la dérivation @var{name}. @var{inputs} doit être une liste de tuples @code{(name drv-path sub-drv)} ; lorsque @var{sub-drv} est omis, @code{\"out\"} est utilisé. @var{modules} est une liste de noms de modules Guile du chemin de recherche actuel qui seront copiés dans le dépôt, compilés et rendus disponibles dans le chemin de chargement pendant l'exécution de @var{exp} — p.@: ex.@: @code{((guix build utils) (guix build gnu-build-system))}." #. type: deffn #: doc/guix.texi:4622 msgid "@var{exp} is evaluated in an environment where @code{%outputs} is bound to a list of output/path pairs, and where @code{%build-inputs} is bound to a list of string/output-path pairs made from @var{inputs}. Optionally, @var{env-vars} is a list of string pairs specifying the name and value of environment variables visible to the builder. The builder terminates by passing the result of @var{exp} to @code{exit}; thus, when @var{exp} returns @code{#f}, the build is considered to have failed." -msgstr "" +msgstr "@var{exp} est évaluée dans une environnement où @code{%outputs} est lié à une liste de paires de sortie/chemin, et où @code{%build-inputs} est lié à une liste de paires de chaînes de caractères et de chemin de sortie construite à partir de @var{inputs}. Éventuellement, @var{env-vars} est une liste de paires de chaînes de caractères spécifiant le nom et la valeur de variables d'environnement visibles pour le constructeur. Le constructeur termine en passant le résultat de @var{exp} à @code{exit} ; ainsi, lorsque @var{exp} renvoie @code{#f}, la construction est considérée en échec." #. type: deffn #: doc/guix.texi:4626 msgid "@var{exp} is built using @var{guile-for-build} (a derivation). When @var{guile-for-build} is omitted or is @code{#f}, the value of the @code{%guile-for-build} fluid is used instead." -msgstr "" +msgstr "@var{exp} est construite avec @var{guile-for-build} (une dérivation). Lorsque @var{guile-for-build} est omis où est @code{#f}, la valeur du fluide @code{%guile-for-build} est utilisée à la place." #. type: deffn #: doc/guix.texi:4631 msgid "See the @code{derivation} procedure for the meaning of @var{references-graphs}, @var{allowed-references}, @var{disallowed-references}, @var{local-build?}, and @var{substitutable?}." -msgstr "" +msgstr "Voir la procédure @code{derivation} pour la signification de @var{references-graph}, @var{allowed-references}, @var{disallowed-references}, @var{local-build?} et @var{substitutable?}." #. type: Plain text #: doc/guix.texi:4636 msgid "Here's an example of a single-output derivation that creates a directory containing one file:" -msgstr "" +msgstr "Voici un exemple de dérivation à sortie unique qui crée un répertoire avec un fichier :" #. type: lisp #: doc/guix.texi:4644 @@ -9049,50 +9057,57 @@ msgid "" " (build-expression->derivation store \"goo\" builder))\n" "\n" msgstr "" +"(let ((builder '(let ((out (assoc-ref %outputs \"out\")))\n" +" (mkdir out) ; create /gnu/store/@dots{}-goo\n" +" (call-with-output-file (string-append out \"/test\")\n" +" (lambda (p)\n" +" (display '(hello guix) p))))))\n" +" (build-expression->derivation store \"goo\" builder))\n" +"\n" #. type: lisp #: doc/guix.texi:4646 #, no-wrap msgid "@result{} # @dots{}>\n" -msgstr "" +msgstr "@result{} # @dots{}>\n" #. type: cindex #: doc/guix.texi:4652 #, no-wrap msgid "monad" -msgstr "" +msgstr "monad" #. type: Plain text #: doc/guix.texi:4658 msgid "The procedures that operate on the store described in the previous sections all take an open connection to the build daemon as their first argument. Although the underlying model is functional, they either have side effects or depend on the current state of the store." -msgstr "" +msgstr "Les procédures qui travaillent sur le dépôt décrites dans les sections précédentes prennent toutes une connexion ouverte au démon de construction comme premier argument. Bien que le modèle sous-jacent soit fonctionnel, elles ont soit des effets de bord, soit dépendent de l'état actuel du dépôt." #. type: Plain text #: doc/guix.texi:4664 msgid "The former is inconvenient: the connection to the build daemon has to be carried around in all those functions, making it impossible to compose functions that do not take that parameter with functions that do. The latter can be problematic: since store operations have side effects and/or depend on external state, they have to be properly sequenced." -msgstr "" +msgstr "Le premier point est embêtant : on doit se balader avec la connexion au démon dans toutes ces fonctions, ce qui rend impossible le fait de composer des fonctions qui ne prennent pas ce paramètre avec des fonctions qui le prennent. Le deuxième point est problématique : comme les opérations sur le dépôt ont des effets de bord ou dépendent d'états externes, elles doivent être enchaînés correctement." #. type: cindex #: doc/guix.texi:4665 #, no-wrap msgid "monadic values" -msgstr "" +msgstr "valeurs monadiques" #. type: cindex #: doc/guix.texi:4666 #, no-wrap msgid "monadic functions" -msgstr "" +msgstr "fonctions monadiques" #. type: Plain text #: doc/guix.texi:4676 msgid "This is where the @code{(guix monads)} module comes in. This module provides a framework for working with @dfn{monads}, and a particularly useful monad for our uses, the @dfn{store monad}. Monads are a construct that allows two things: associating ``context'' with values (in our case, the context is the store), and building sequences of computations (here computations include accesses to the store). Values in a monad---values that carry this additional context---are called @dfn{monadic values}; procedures that return such values are called @dfn{monadic procedures}." -msgstr "" +msgstr "C'est là que le module @code{(guix monads)} arrive à la rescousse. Ce module fournit un cadre pour travailler avec des @dfn{monads}, en particulier une monad très utile pour notre usage, la @dfn{monad du dépôt}. Les monads sont des constructions qui permettent deux choses : associer un « contexte » avec une valeur (dans notre cas, le contexte est le dépôt) et construire une séquence de calculs (ici les calculs comprennent des accès au dépôt). Les valeurs dans une monad — les valeurs qui contiennent ce contexte supplémentaire — sont appelées des @dfn{valeurs monadiques} ; les procédures qui renvoient ce genre de valeur sont appelées des @dfn{procédures monadiques}." #. type: Plain text #: doc/guix.texi:4678 msgid "Consider this ``normal'' procedure:" -msgstr "" +msgstr "Considérez cette procédure « normale » :" #. type: example #: doc/guix.texi:4687 @@ -9106,11 +9121,18 @@ msgid "" " (build-expression->derivation store \"sh\"\n" " `(symlink ,sh %output))))\n" msgstr "" +"(define (sh-symlink store)\n" +" ;; Renvoie une dérivation qui crée un lien symbolique vers l'exécutable « bash ».\n" +" (let* ((drv (package-derivation store bash))\n" +" (out (derivation->output-path drv))\n" +" (sh (string-append out \"/bin/bash\")))\n" +" (build-expression->derivation store \"sh\"\n" +" `(symlink ,sh %output))))\n" #. type: Plain text #: doc/guix.texi:4691 msgid "Using @code{(guix monads)} and @code{(guix gexp)}, it may be rewritten as a monadic function:" -msgstr "" +msgstr "En utilisant @code{(guix monads)} et @code{(guix gexp)}, on peut la réécrire en une fonction monadique :" #. type: example #: doc/guix.texi:4699 @@ -9123,16 +9145,22 @@ msgid "" " #~(symlink (string-append #$drv \"/bin/bash\")\n" " #$output))))\n" msgstr "" +"(define (sh-symlink)\n" +" ;; Pareil, mais renvoie une valeur monadique.\n" +" (mlet %store-monad ((drv (package->derivation bash)))\n" +" (gexp->derivation \"sh\"\n" +" #~(symlink (string-append #$drv \"/bin/bash\")\n" +" #$output))))\n" #. type: Plain text #: doc/guix.texi:4706 msgid "There are several things to note in the second version: the @code{store} parameter is now implicit and is ``threaded'' in the calls to the @code{package->derivation} and @code{gexp->derivation} monadic procedures, and the monadic value returned by @code{package->derivation} is @dfn{bound} using @code{mlet} instead of plain @code{let}." -msgstr "" +msgstr "Il y a plusieurs choses à remarquer avec cette deuxième version : le paramètre @code{store} est maintenant implicitement « enfilé » dans les appels aux procédures monadiques @code{package->derivation} et @code{gexp->derivation}, et la valeur monadique renvoyée par @code{package->derivation} est @dfn{liée} avec @code{mlet} plutôt qu'avec un simple @code{let}." #. type: Plain text #: doc/guix.texi:4710 msgid "As it turns out, the call to @code{package->derivation} can even be omitted since it will take place implicitly, as we will see later (@pxref{G-Expressions}):" -msgstr "" +msgstr "Il se trouve que l'appel à @code{package->derivation} peut même être omis puisqu'il aura lieu implicitement, comme nous le verrons plus tard (@pxref{G-Expressions}) :" #. type: example #: doc/guix.texi:4716 @@ -9143,11 +9171,15 @@ msgid "" " #~(symlink (string-append #$bash \"/bin/bash\")\n" " #$output)))\n" msgstr "" +"(define (sh-symlink)\n" +" (gexp->derivation \"sh\"\n" +" #~(symlink (string-append #$bash \"/bin/bash\")\n" +" #$output)))\n" #. type: Plain text #: doc/guix.texi:4725 msgid "Calling the monadic @code{sh-symlink} has no effect. As someone once said, ``you exit a monad like you exit a building on fire: by running''. So, to exit the monad and get the desired effect, one must use @code{run-with-store}:" -msgstr "" +msgstr "L'appel à la procédure monadique @code{sh-symlink} n'a aucun effet. En anglais on pourrait dire « you exit a monad like you exit a building on fire: by running »@footnote{NdT : « on sort d'une monad comme d'un immeuble en flamme, en courant ». Le jeu de mot est perdu à la traduction : courrir et lancer utilisent le même verbe @i{run} en anglais.}. Donc, pour sortir de la monad et obtenir l'effet escompté, on doit utiliser @code{run-with-store}." #. type: example #: doc/guix.texi:4729 @@ -9156,11 +9188,13 @@ msgid "" "(run-with-store (open-connection) (sh-symlink))\n" "@result{} /gnu/store/...-sh-symlink\n" msgstr "" +"(run-with-store (open-connection) (sh-symlink))\n" +"@result{} /gnu/store/...-sh-symlink\n" #. type: Plain text #: doc/guix.texi:4735 msgid "Note that the @code{(guix monad-repl)} module extends the Guile REPL with new ``meta-commands'' to make it easier to deal with monadic procedures: @code{run-in-store}, and @code{enter-store-monad}. The former is used to ``run'' a single monadic value through the store:" -msgstr "" +msgstr "Remarquez que le module @code{(guix monad-repl)} étend la console Guile avec de nouvelles « méta-commandes » pour rendre plus facile la manipulation de procédures monadiques : @code{run-in-store} et @code{enter-store-monad}. La première est utilisée pour « lancer » une seule valeur monadique à travers le dépôt :" #. type: example #: doc/guix.texi:4739 @@ -9169,11 +9203,13 @@ msgid "" "scheme@@(guile-user)> ,run-in-store (package->derivation hello)\n" "$1 = # @dots{}>\n" msgstr "" +"scheme@@(guile-user)> ,run-in-store (package->derivation hello)\n" +"$1 = # @dots{}>\n" #. type: Plain text #: doc/guix.texi:4743 msgid "The latter enters a recursive REPL, where all the return values are automatically run through the store:" -msgstr "" +msgstr "La deuxième entre dans une console récursive, où toutes les valeurs de retour sont automatiquement lancées à travers le dépôt :" #. type: example #: doc/guix.texi:4752 @@ -9187,49 +9223,56 @@ msgid "" "store-monad@@(guile-user) [1]> ,q\n" "scheme@@(guile-user)>\n" msgstr "" +"scheme@@(guile-user)> ,enter-store-monad\n" +"store-monad@@(guile-user) [1]> (package->derivation hello)\n" +"$2 = # @dots{}>\n" +"store-monad@@(guile-user) [1]> (text-file \"foo\" \"Hello!\")\n" +"$3 = \"/gnu/store/@dots{}-foo\"\n" +"store-monad@@(guile-user) [1]> ,q\n" +"scheme@@(guile-user)>\n" #. type: Plain text #: doc/guix.texi:4757 msgid "Note that non-monadic values cannot be returned in the @code{store-monad} REPL." -msgstr "" +msgstr "Remarquez qu'on ne peut pas renvoyer de valeur non monadique dans la console @code{store-monad}." #. type: Plain text #: doc/guix.texi:4760 msgid "The main syntactic forms to deal with monads in general are provided by the @code{(guix monads)} module and are described below." -msgstr "" +msgstr "Les formes syntaxiques principales pour utiliser des monads en général sont disponibles dans le module @code{(guix monads)} et sont décrites ci-dessous." #. type: deffn #: doc/guix.texi:4761 #, no-wrap msgid "{Scheme Syntax} with-monad @var{monad} @var{body} ..." -msgstr "" +msgstr "{Syntaxe Scheme} with-monad @var{monad} @var{body} ..." #. type: deffn #: doc/guix.texi:4764 msgid "Evaluate any @code{>>=} or @code{return} forms in @var{body} as being in @var{monad}." -msgstr "" +msgstr "Évalue n'importe quelle forme @code{>>=} ou @code{return} dans @var{body} comme une @var{monad}." #. type: deffn #: doc/guix.texi:4766 #, no-wrap msgid "{Scheme Syntax} return @var{val}" -msgstr "" +msgstr "{Syntaxe Scheme} return @var{val}" #. type: deffn #: doc/guix.texi:4768 msgid "Return a monadic value that encapsulates @var{val}." -msgstr "" +msgstr "Renvoie une valeur monadique qui encapsule @var{val}." #. type: deffn #: doc/guix.texi:4770 #, no-wrap msgid "{Scheme Syntax} >>= @var{mval} @var{mproc} ..." -msgstr "" +msgstr "{Syntaxe Scheme} >>= @var{mval} @var{mproc} ..." #. type: deffn #: doc/guix.texi:4777 msgid "@dfn{Bind} monadic value @var{mval}, passing its ``contents'' to monadic procedures @var{mproc}@dots{}@footnote{This operation is commonly referred to as ``bind'', but that name denotes an unrelated procedure in Guile. Thus we use this somewhat cryptic symbol inherited from the Haskell language.}. There can be one @var{mproc} or several of them, as in this example:" -msgstr "" +msgstr "@dfn{Lie} une valeur monadique @var{mval}, en passant son « contenu » aux procédures monadiques @var{mproc}@dots{}@footnote{Cette opération est souvent appelée « bind », mais ce nom dénote une procédure qui n'a rien à voir en Guile. Ainsi, nous empruntons ce symbole quelque peu cryptique au langage Haskell}. Il peut y avoir une ou plusieurs @code{mproc}, comme dans cet exemple :" #. type: example #: doc/guix.texi:4785 @@ -9243,6 +9286,13 @@ msgid "" " 'some-state)\n" "\n" msgstr "" +"(run-with-state\n" +" (with-monad %state-monad\n" +" (>>= (return 1)\n" +" (lambda (x) (return (+ 1 x)))\n" +" (lambda (x) (return (* 2 x)))))\n" +" 'some-state)\n" +"\n" #. type: example #: doc/guix.texi:4788 @@ -9251,98 +9301,102 @@ msgid "" "@result{} 4\n" "@result{} some-state\n" msgstr "" +"@result{} 4\n" +"@result{} some-state\n" #. type: deffn #: doc/guix.texi:4791 #, no-wrap msgid "{Scheme Syntax} mlet @var{monad} ((@var{var} @var{mval}) ...) @" -msgstr "" +msgstr "{Syntaxe Scheme} mlet @var{monad} ((@var{var} @var{mval}) ...) @" #. type: deffn #: doc/guix.texi:4793 msgid "@var{body} ..." -msgstr "" +msgstr "@var{body} ..." #. type: deffnx #: doc/guix.texi:4793 #, no-wrap msgid "{Scheme Syntax} mlet* @var{monad} ((@var{var} @var{mval}) ...) @" -msgstr "" +msgstr "{Syntaxe Scheme} mlet* @var{monad} ((@var{var} @var{mval}) ...) @" #. type: deffn #: doc/guix.texi:4805 msgid "@var{body} ... Bind the variables @var{var} to the monadic values @var{mval} in @var{body}, which is a sequence of expressions. As with the bind operator, this can be thought of as ``unpacking'' the raw, non-monadic value ``contained'' in @var{mval} and making @var{var} refer to that raw, non-monadic value within the scope of the @var{body}. The form (@var{var} -> @var{val}) binds @var{var} to the ``normal'' value @var{val}, as per @code{let}. The binding operations occur in sequence from left to right. The last expression of @var{body} must be a monadic expression, and its result will become the result of the @code{mlet} or @code{mlet*} when run in the @var{monad}." msgstr "" +"@var{body} ...\n" +"Lie les variables @var{var} aux valeurs monadiques @var{mval} dans @var{body}, une séquence d'expressions. Comme avec l'opérateur de liaison, on peut réfléchir comme si on « ouvrait » la valeur non-monadique « contenue » dans @var{mval} et comme si on faisait en sorte que @var{var} se réfère à cette valeur pure, non-monadique, dans la portée de @var{body}. La forme (@var{var} -> @var{val}) lie @var{var} à la valeur « normale » @var{val}, comme @code{let}. L'opération de liaison a lieu en séquence de la gauche vers la droite. La dernière expression de @var{body} doit être une expression monadique et son résultat deviendra le résultat de @code{mlet} ou @code{mlet*} lorsque lancé dans la @var{monad}." #. type: deffn #: doc/guix.texi:4808 msgid "@code{mlet*} is to @code{mlet} what @code{let*} is to @code{let} (@pxref{Local Bindings,,, guile, GNU Guile Reference Manual})." -msgstr "" +msgstr "@code{mlet*} est à @code{mlet} ce que @code{let*} est à @code{let} (@pxref{Local Bindings,,, guile, GNU Guile Reference Manual})." #. type: deffn #: doc/guix.texi:4810 #, no-wrap msgid "{Scheme System} mbegin @var{monad} @var{mexp} ..." -msgstr "" +msgstr "{Système Scheme} mbegin @var{monad} @var{mexp} ..." #. type: deffn #: doc/guix.texi:4814 msgid "Bind @var{mexp} and the following monadic expressions in sequence, returning the result of the last expression. Every expression in the sequence must be a monadic expression." -msgstr "" +msgstr "Lie @var{mexp} et les expressions monadiques suivantes en séquence, et renvoie le résultat de la dernière expression. Chaque expression dans la séquence doit être une expression monadique." #. type: deffn #: doc/guix.texi:4818 msgid "This is akin to @code{mlet}, except that the return values of the monadic expressions are ignored. In that sense, it is analogous to @code{begin}, but applied to monadic expressions." -msgstr "" +msgstr "Cette procédure est similaire à @code{mlet}, sauf que les valeurs de retour des expressions monadiques sont ignorées. Dans ce sens, elle est analogue à @code{begin}, mais appliqué à des expressions monadiques." #. type: deffn #: doc/guix.texi:4820 #, no-wrap msgid "{Scheme System} mwhen @var{condition} @var{mexp0} @var{mexp*} ..." -msgstr "" +msgstr "{Système Scheme} mwhen @var{condition} @var{mexp0} @var{mexp*} ..." #. type: deffn #: doc/guix.texi:4825 msgid "When @var{condition} is true, evaluate the sequence of monadic expressions @var{mexp0}..@var{mexp*} as in an @code{mbegin}. When @var{condition} is false, return @code{*unspecified*} in the current monad. Every expression in the sequence must be a monadic expression." -msgstr "" +msgstr "Lorsque la @var{condition} est vraie, évalue la séquence des expressions monadiques @var{mexp0}..@var{mexp*} comme dans un @code{mbegin}. Lorsque la @var{condition} est fausse, renvoie @code{*unspecified*} dans la monad actuelle. Cahque expression dans la séquence doit être une expression monadique." #. type: deffn #: doc/guix.texi:4827 #, no-wrap msgid "{Scheme System} munless @var{condition} @var{mexp0} @var{mexp*} ..." -msgstr "" +msgstr "{Système Scheme} munless @var{condition} @var{mexp0} @var{mexp*} ..." #. type: deffn #: doc/guix.texi:4832 msgid "When @var{condition} is false, evaluate the sequence of monadic expressions @var{mexp0}..@var{mexp*} as in an @code{mbegin}. When @var{condition} is true, return @code{*unspecified*} in the current monad. Every expression in the sequence must be a monadic expression." -msgstr "" +msgstr "Lorsque la @var{condition} est fausse, évalue la séquence des expressions monadiques @var{mexp0}..@var{mexp*} comme dans un @code{mbegin}. Lorsque la @var{condition} est vraie, renvoie @code{*unspecified*} dans la monad actuelle. Cahque expression dans la séquence doit être une expression monadique." #. type: cindex #: doc/guix.texi:4834 #, no-wrap msgid "state monad" -msgstr "" +msgstr "monad d'état" #. type: Plain text #: doc/guix.texi:4838 msgid "The @code{(guix monads)} module provides the @dfn{state monad}, which allows an additional value---the state---to be @emph{threaded} through monadic procedure calls." -msgstr "" +msgstr "Le module @code{(guix monads)} fournit la @dfn{monad d'état} qui permet à une valeur supplémentaire — l'état — d'être enfilée à travers les appels de procédures." #. type: defvr #: doc/guix.texi:4839 #, no-wrap msgid "{Scheme Variable} %state-monad" -msgstr "" +msgstr "{Variable Scheme} %state-monad" #. type: defvr #: doc/guix.texi:4842 msgid "The state monad. Procedures in the state monad can access and change the state that is threaded." -msgstr "" +msgstr "La monad d'état. les procédure dans la monad d'état peuvent accéder et modifier l'état qui est enfilé." #. type: defvr #: doc/guix.texi:4846 msgid "Consider the example below. The @code{square} procedure returns a value in the state monad. It returns the square of its argument, but also increments the current state value:" -msgstr "" +msgstr "Considérez l'exemple ci-dessous. La procédure @code{square} renvoie une valeur dans la monad d'état. Elle renvoie le carré de son argument, mais incrémente aussi la valeur actuelle de l'état :" #. type: example #: doc/guix.texi:4853 @@ -9355,6 +9409,12 @@ msgid "" " (return (* x x)))))\n" "\n" msgstr "" +"(define (square x)\n" +" (mlet %state-monad ((count (current-state)))\n" +" (mbegin %state-monad\n" +" (set-current-state (+ 1 count))\n" +" (return (* x x)))))\n" +"\n" #. type: example #: doc/guix.texi:4857 @@ -9364,135 +9424,140 @@ msgid "" "@result{} (0 1 4)\n" "@result{} 3\n" msgstr "" +"(run-with-state (sequence %state-monad (map square (iota 3))) 0)\n" +"@result{} (0 1 4)\n" +"@result{} 3\n" #. type: defvr #: doc/guix.texi:4861 msgid "When ``run'' through @var{%state-monad}, we obtain that additional state value, which is the number of @code{square} calls." -msgstr "" +msgstr "Lorsqu'on la lance à travers @var{%state-monad}, on obtient cet valeur d'état supplémentaire, qui est le nombre d'appels à @code{square}." #. type: deffn #: doc/guix.texi:4863 #, no-wrap msgid "{Monadic Procedure} current-state" -msgstr "" +msgstr "{Procédure Monadic} current-state" #. type: deffn #: doc/guix.texi:4865 msgid "Return the current state as a monadic value." -msgstr "" +msgstr "Renvoie l'état actuel dans une valeur monadique." #. type: deffn #: doc/guix.texi:4867 #, no-wrap msgid "{Monadic Procedure} set-current-state @var{value}" -msgstr "" +msgstr "{Procédure Monadic} set-current-state @var{value}" #. type: deffn #: doc/guix.texi:4870 msgid "Set the current state to @var{value} and return the previous state as a monadic value." -msgstr "" +msgstr "Initialise l'état actuel à @var{value} et renvoie l'état précédent dans une valeur monadique." #. type: deffn #: doc/guix.texi:4872 #, no-wrap msgid "{Monadic Procedure} state-push @var{value}" -msgstr "" +msgstr "{Procédure Monadic} state-push @var{value}" #. type: deffn #: doc/guix.texi:4875 msgid "Push @var{value} to the current state, which is assumed to be a list, and return the previous state as a monadic value." -msgstr "" +msgstr "Pousse @var{value} sur l'état actuel, qui est supposé être une liste, et renvoie l'état précédent dans une valeur monadique." #. type: deffn #: doc/guix.texi:4877 #, no-wrap msgid "{Monadic Procedure} state-pop" -msgstr "" +msgstr "{Procédure Monadic} state-pop" #. type: deffn #: doc/guix.texi:4880 msgid "Pop a value from the current state and return it as a monadic value. The state is assumed to be a list." -msgstr "" +msgstr "Récupère (pop) une valeur dans l'état actuel et la renvoie comme une valeur monadique. L'état est supposé être une liste." #. type: deffn #: doc/guix.texi:4882 #, no-wrap msgid "{Scheme Procedure} run-with-state @var{mval} [@var{state}]" -msgstr "" +msgstr "{Procédure Scheme} run-with-state @var{mval} [@var{state}]" #. type: deffn #: doc/guix.texi:4885 msgid "Run monadic value @var{mval} starting with @var{state} as the initial state. Return two values: the resulting value, and the resulting state." -msgstr "" +msgstr "Lance la valeur monadique @var{mval} avec @var{state} comme valeur initiale. Renvoie deux valeurs : la valeur du résultat et l'état du résultat." #. type: Plain text #: doc/guix.texi:4889 msgid "The main interface to the store monad, provided by the @code{(guix store)} module, is as follows." -msgstr "" +msgstr "L'interface principale avec la monad du dépôt, fournit par le module @code{(guix store)}, est la suivante." #. type: defvr #: doc/guix.texi:4890 #, no-wrap msgid "{Scheme Variable} %store-monad" -msgstr "" +msgstr "{Variable Scheme} %store-monad" #. type: defvr #: doc/guix.texi:4892 msgid "The store monad---an alias for @var{%state-monad}." -msgstr "" +msgstr "La monad du dépôt — un alias pour @var{%state-monad}." #. type: defvr #: doc/guix.texi:4896 msgid "Values in the store monad encapsulate accesses to the store. When its effect is needed, a value of the store monad must be ``evaluated'' by passing it to the @code{run-with-store} procedure (see below.)" -msgstr "" +msgstr "Les valeurs dans la monad du dépôt encapsulent des accès au dépôt. Lorsque son effet est requis, une valeur de la monad du dépôt doit être « évaluée » en la passant à la procédure @code{run-with-store} (voir plus bas)." #. type: deffn #: doc/guix.texi:4898 #, no-wrap msgid "{Scheme Procedure} run-with-store @var{store} @var{mval} [#:guile-for-build] [#:system (%current-system)]" -msgstr "" +msgstr "{Procédure Scheme} run-with-store @var{store} @var{mval} [#:guile-for-build] [#:system (%current-system)]" #. type: deffn #: doc/guix.texi:4901 msgid "Run @var{mval}, a monadic value in the store monad, in @var{store}, an open store connection." -msgstr "" +msgstr "Lance @var{mval}, une valeur monadique dans la monad du dépôt, dans @var{store}, une connexion ouvert au dépôt." #. type: deffn #: doc/guix.texi:4903 #, no-wrap msgid "{Monadic Procedure} text-file @var{name} @var{text} [@var{references}]" -msgstr "" +msgstr "{Procédure Monadique} text-file @var{name} @var{text} [@var{references}]" #. type: deffn #: doc/guix.texi:4907 msgid "Return as a monadic value the absolute file name in the store of the file containing @var{text}, a string. @var{references} is a list of store items that the resulting text file refers to; it defaults to the empty list." -msgstr "" +msgstr "Renvoie une valeur monadique correspondant au nom de fichier dans le dépôt du fichier contenant @var{text}, une chaîne de caractères. @var{references} est une liste d'éléments du dépôt auxquels le fichier texte en résultat se réfère ; c'est la liste vide par défaut." #. type: deffn #: doc/guix.texi:4909 #, no-wrap msgid "{Monadic Procedure} interned-file @var{file} [@var{name}] @" -msgstr "" +msgstr "{Procédure Monadique} interned-file @var{file} [@var{name}] @" #. type: deffn #: doc/guix.texi:4914 msgid "[#:recursive? #t] [#:select? (const #t)] Return the name of @var{file} once interned in the store. Use @var{name} as its store name, or the basename of @var{file} if @var{name} is omitted." msgstr "" +"[#:recursive? #t] [#:select? (const #t)]\n" +"Renvoie le nom de @var{file} une fois ajouté au dépôt. Utilise @var{name} comme nom dans le dépôt ou le nom de fichier de @var{file} si @var{name} est omis." #. type: deffn #: doc/guix.texi:4918 doc/guix.texi:5330 msgid "When @var{recursive?} is true, the contents of @var{file} are added recursively; if @var{file} designates a flat file and @var{recursive?} is true, its contents are added, and its permission bits are kept." -msgstr "" +msgstr "Lorsque @var{recursive?} est vraie, le contenu de @var{file} est ajouté récursivement ; si @var{file} désigne un fichier simple et que @var{recursive?} est vrai, son contenu est ajouté et ses bits de permissions sont préservés." #. type: deffn #: doc/guix.texi:4923 doc/guix.texi:5335 msgid "When @var{recursive?} is true, call @code{(@var{select?} @var{file} @var{stat})} for each directory entry, where @var{file} is the entry's absolute file name and @var{stat} is the result of @code{lstat}; exclude entries for which @var{select?} does not return true." -msgstr "" +msgstr "Lorsque @var{recursive?} est vraie, appelle @code{(@var{select?} @var{file} @var{stat})} pour chaque répertoire où @var{file} est le nom de fichier absolu de l'entrée et @var{stat} est le résultat de @code{lstat} ; à l'exception des entrées pour lesquelles @var{select?} ne renvoie pas vrai." #. type: deffn #: doc/guix.texi:4925 msgid "The example below adds a file to the store, under two different names:" -msgstr "" +msgstr "L'exemple ci-dessous ajoute un fichier au dépôt, sous deux noms différents :" #. type: example #: doc/guix.texi:4931 @@ -9504,114 +9569,124 @@ msgid "" " (return (list a b))))\n" "\n" msgstr "" +"(run-with-store (open-connection)\n" +" (mlet %store-monad ((a (interned-file \"README\"))\n" +" (b (interned-file \"README\" \"LEGU-MIN\")))\n" +" (return (list a b))))\n" +"\n" #. type: example #: doc/guix.texi:4933 #, no-wrap msgid "@result{} (\"/gnu/store/rwm@dots{}-README\" \"/gnu/store/44i@dots{}-LEGU-MIN\")\n" -msgstr "" +msgstr "@result{} (\"/gnu/store/rwm@dots{}-README\" \"/gnu/store/44i@dots{}-LEGU-MIN\")\n" #. type: Plain text #: doc/guix.texi:4939 msgid "The @code{(guix packages)} module exports the following package-related monadic procedures:" -msgstr "" +msgstr "Le module @code{(guix packages)} exporte les procédures monadiques liées aux paquets suivantes :" #. type: deffn #: doc/guix.texi:4940 #, no-wrap msgid "{Monadic Procedure} package-file @var{package} [@var{file}] @" -msgstr "" +msgstr "{Procédure Monadique} package-file @var{package} [@var{file}] @" #. type: deffn #: doc/guix.texi:4948 msgid "[#:system (%current-system)] [#:target #f] @ [#:output \"out\"] Return as a monadic value in the absolute file name of @var{file} within the @var{output} directory of @var{package}. When @var{file} is omitted, return the name of the @var{output} directory of @var{package}. When @var{target} is true, use it as a cross-compilation target triplet." msgstr "" +"[#:system (%current-system)] [#:target #f] @\n" +"[#:output \"out\"]\n" +"Renvoie une valeur monadique qui contient le nom de fichier absolu de @var{file} dans le répertoire @var{output} de @var{package}. Lorsque @var{file} est omis, renvoie le nom du répertoire @var{output} de @var{package}. Lorsque @var{target} est vrai, l'utilise comme un triplet de cible pour la compilation croisée." #. type: deffn #: doc/guix.texi:4950 #, no-wrap msgid "{Monadic Procedure} package->derivation @var{package} [@var{system}]" -msgstr "" +msgstr "{Procédure Monadique} package->derivation @var{package} [@var{system}]" #. type: deffnx #: doc/guix.texi:4951 #, no-wrap msgid "{Monadic Procedure} package->cross-derivation @var{package} @" -msgstr "" +msgstr "{Procédure Monadique} package->cross-derivation @var{package} @" #. type: deffn #: doc/guix.texi:4955 msgid "@var{target} [@var{system}] Monadic version of @code{package-derivation} and @code{package-cross-derivation} (@pxref{Defining Packages})." msgstr "" +"@var{target} [@var{system}]\n" +"Version monadique de @code{package-derivation} et @code{package-cross-derivation} (@pxref{Defining Packages})." #. type: cindex #: doc/guix.texi:4961 #, no-wrap msgid "G-expression" -msgstr "" +msgstr "G-expression" #. type: cindex #: doc/guix.texi:4962 #, no-wrap msgid "build code quoting" -msgstr "" +msgstr "quoting du code de construction" #. type: Plain text #: doc/guix.texi:4968 msgid "So we have ``derivations'', which represent a sequence of build actions to be performed to produce an item in the store (@pxref{Derivations}). These build actions are performed when asking the daemon to actually build the derivations; they are run by the daemon in a container (@pxref{Invoking guix-daemon})." -msgstr "" +msgstr "On a donc des « dérivations » qui représentent une séquence d'actions de construction à effectuer pour produire un élément du dépôt (@pxref{Derivations}). Ces actions de construction sont effectuées lorsqu'on demande au démon de construire effectivement les dérivations ; elles sont lancées par le démon dans un conteneur (@pxref{Invoking guix-daemon})." #. type: cindex #: doc/guix.texi:4969 #, no-wrap msgid "strata of code" -msgstr "" +msgstr "strate de code" #. type: Plain text #: doc/guix.texi:4981 msgid "It should come as no surprise that we like to write these build actions in Scheme. When we do that, we end up with two @dfn{strata} of Scheme code@footnote{The term @dfn{stratum} in this context was coined by Manuel Serrano et al.@: in the context of their work on Hop. Oleg Kiselyov, who has written insightful @url{http://okmij.org/ftp/meta-programming/#meta-scheme, essays and code on this topic}, refers to this kind of code generation as @dfn{staging}.}: the ``host code''---code that defines packages, talks to the daemon, etc.---and the ``build code''---code that actually performs build actions, such as making directories, invoking @command{make}, etc." -msgstr "" +msgstr "Ça ne devrait pas vous surprendre, mais nous aimons écrire ces actions de construction en Scheme. Lorsqu'on fait ça, on fini avec deux @dfn{strates} de code Scheme@footnote{Le terme @dfn{strate} dans ce contexte a été inventé par Manuel Serrano et ses collaborateurs dans le contexte de leur travaux sur Hop. Oleg Kiselyov, qui a écrit des @url{http://okmij.org/ftp/meta-programming/#meta-scheme, essais perspicaces et du code sur le sujet}, utilise le terme de « mise en scène » pour ce genre de génération de code.} : le « code hôte » — le code qui défini les paquets, parle au démon, etc — et le « code côté construction » — le code qui effectue effectivement les actions de construction, comme créer des répertoires, invoquer @code{make}, etc." #. type: Plain text #: doc/guix.texi:4988 msgid "To describe a derivation and its build actions, one typically needs to embed build code inside host code. It boils down to manipulating build code as data, and the homoiconicity of Scheme---code has a direct representation as data---comes in handy for that. But we need more than the normal @code{quasiquote} mechanism in Scheme to construct build expressions." -msgstr "" +msgstr "Pour décrire une dérivation et ses actions de construction, on a typiquement besoin d'intégrer le code de construction dans le code hôte. Ça revient à manipuler le code de construction comme de la donnée, et l'homoiconicité de Scheme — le code a une représentation directe en tant que donnée — est très utile pour cela. Mais on a besoin de plus que le mécanisme de @code{quasiquote} en Scheme pour construire des expressions de construction." #. type: Plain text #: doc/guix.texi:4997 msgid "The @code{(guix gexp)} module implements @dfn{G-expressions}, a form of S-expressions adapted to build expressions. G-expressions, or @dfn{gexps}, consist essentially of three syntactic forms: @code{gexp}, @code{ungexp}, and @code{ungexp-splicing} (or simply: @code{#~}, @code{#$}, and @code{#$@@}), which are comparable to @code{quasiquote}, @code{unquote}, and @code{unquote-splicing}, respectively (@pxref{Expression Syntax, @code{quasiquote},, guile, GNU Guile Reference Manual}). However, there are major differences:" -msgstr "" +msgstr "Le module @code{(guix gexp)} implémente les @dfn{G-expressions}, une forme de S-expression adaptée aux expressions de construction. Les G-expression, ou @dfn{gexps}, consistent en gros en trois formes syntaxiques : @code{gexp}, @code{ungexp} et @code{ungexp-splicing} (ou plus simplement : @code{#~}, @code{#$} et @code{#$@@}), qui sont comparable à @code{quasiquote}, @code{unquote} ett @code{unquote-splicing} respectivement (@pxref{Expression Syntax, @code{quasiquote},, guile, GNU Guile Reference Manual}). Cependant il y a des différences majeures :" #. type: itemize #: doc/guix.texi:5002 msgid "Gexps are meant to be written to a file and run or manipulated by other processes." -msgstr "" +msgstr "Les Gexps sont conçues pour être écrites dans un fichier et être lancées ou manipulées par d'autres processus." #. type: itemize #: doc/guix.texi:5007 msgid "When a high-level object such as a package or derivation is unquoted inside a gexp, the result is as if its output file name had been introduced." -msgstr "" +msgstr "Lorsqu'un objet de haut-niveau comme un paquet ou une dérivation est unquotée dans une gexp, le résultat est comme si le nom de fichier de son résultat avait été introduit." #. type: itemize #: doc/guix.texi:5012 msgid "Gexps carry information about the packages or derivations they refer to, and these dependencies are automatically added as inputs to the build processes that use them." -msgstr "" +msgstr "Les gexps transportent des informatinos sur les paquets ou les dérivations auxquels elles se réfèrent, et ces dépendances sont automatiquement ajoutées comme des entrées du processus de construction qui les utilise." #. type: cindex #: doc/guix.texi:5014 doc/guix.texi:5517 #, no-wrap msgid "lowering, of high-level objects in gexps" -msgstr "" +msgstr "abaissement, des objets haut-niveau dans les gepxs" #. type: Plain text #: doc/guix.texi:5024 msgid "This mechanism is not limited to package and derivation objects: @dfn{compilers} able to ``lower'' other high-level objects to derivations or files in the store can be defined, such that these objects can also be inserted into gexps. For example, a useful type of high-level objects that can be inserted in a gexp is ``file-like objects'', which make it easy to add files to the store and to refer to them in derivations and such (see @code{local-file} and @code{plain-file} below.)" -msgstr "" +msgstr "Ce mécanisme n'est pas limité aux paquets et aux dérivations : on peut définir des @dfn{compilateurs} capable « d'abaisser » d'autres objets de haut-niveau ou des fichiers dans le dépôt, pour que ces objets puissent aussi être insérés dans des gexps. Par exemple, des objets haut-niveau utiles qui pourraient être insérées dans une gexp sont les « objets simili-fichiers », qui rendent facile l'ajout de fichiers dans le dépôt et les références vers eux dans les dérivations et autres (voir @code{local-file} et @code{plain-file} ci-dessous)." #. type: Plain text #: doc/guix.texi:5026 msgid "To illustrate the idea, here is an example of a gexp:" -msgstr "" +msgstr "Pour illustrer cette idée, voici un exemple de gexp :" #. type: example #: doc/guix.texi:5034 @@ -9624,33 +9699,39 @@ msgid "" " (symlink (string-append #$coreutils \"/bin/ls\")\n" " \"list-files\")))\n" msgstr "" +"(define build-exp\n" +" #~(begin\n" +" (mkdir #$output)\n" +" (chdir #$output)\n" +" (symlink (string-append #$coreutils \"/bin/ls\")\n" +" \"list-files\")))\n" #. type: Plain text #: doc/guix.texi:5039 msgid "This gexp can be passed to @code{gexp->derivation}; we obtain a derivation that builds a directory containing exactly one symlink to @file{/gnu/store/@dots{}-coreutils-8.22/bin/ls}:" -msgstr "" +msgstr "Cette gexp peut être passée à @code{gexp->derivation} ; on obtient une dérivation qui construit une répertoire contenant exactement un lien symbolique à @file{/gnu/store/@dots{}-coreutils-8.22/bin/ls} :" #. type: example #: doc/guix.texi:5042 #, no-wrap msgid "(gexp->derivation \"the-thing\" build-exp)\n" -msgstr "" +msgstr "(gexp->derivation \"the-thing\" build-exp)\n" #. type: Plain text #: doc/guix.texi:5050 msgid "As one would expect, the @code{\"/gnu/store/@dots{}-coreutils-8.22\"} string is substituted to the reference to the @var{coreutils} package in the actual build code, and @var{coreutils} is automatically made an input to the derivation. Likewise, @code{#$output} (equivalent to @code{(ungexp output)}) is replaced by a string containing the directory name of the output of the derivation." -msgstr "" +msgstr "Comme on pourrait s'y attendre, la chaîne @code{\"/gnu/store/@dots{}-coreutils-8.22\"} est substituée à la place de la référence au paquet @var{coreutils} dans le code de construction final, et @var{coreutils} est automatiquement devenu une entrée de la dérivation. De même, @code{#$output} (équivalent à @code{(ungexp output)}) est remplacé par une chaîne de caractères contenant le nom du répertoire de la sortie de la dérivation." #. type: cindex #: doc/guix.texi:5051 #, no-wrap msgid "cross compilation" -msgstr "" +msgstr "compilation croisée" #. type: Plain text #: doc/guix.texi:5057 msgid "In a cross-compilation context, it is useful to distinguish between references to the @emph{native} build of a package---that can run on the host---versus references to cross builds of a package. To that end, the @code{#+} plays the same role as @code{#$}, but is a reference to a native package build:" -msgstr "" +msgstr "Dans le contexte d'une compilation croisée, il est utile de distinguer entre des références à la construction @emph{native} d'un paquet — qui peut être lancé par l'hôte — et des références à la construction croisée d'un paquet. Pour cela, @code{#+} joue le même rôle que @code{#$}, mais référence une construction native d'un paquet :" #. type: example #: doc/guix.texi:5067 @@ -9665,28 +9746,36 @@ msgid "" " (string-append #$output \"/bin/vi\")))\n" " #:target \"mips64el-linux-gnu\")\n" msgstr "" +"(gexp->derivation \"vi\"\n" +" #~(begin\n" +" (mkdir #$output)\n" +" (system* (string-append #+coreutils \"/bin/ln\")\n" +" \"-s\"\n" +" (string-append #$emacs \"/bin/emacs\")\n" +" (string-append #$output \"/bin/vi\")))\n" +" #:target \"mips64el-linux-gnu\")\n" #. type: Plain text #: doc/guix.texi:5073 msgid "In the example above, the native build of @var{coreutils} is used, so that @command{ln} can actually run on the host; but then the cross-compiled build of @var{emacs} is referenced." -msgstr "" +msgstr "Dans l'exemple ci-dessus, la construction native de @var{coreutils} est utilisée, pour que @command{ln} puisse effectivement être lancé sur l'hôte ; mais ensuite la construction croisée d'@var{emacs} est utilisée." #. type: cindex #: doc/guix.texi:5074 #, no-wrap msgid "imported modules, for gexps" -msgstr "" +msgstr "modules importés, pour les gexps" #. type: findex #: doc/guix.texi:5075 #, no-wrap msgid "with-imported-modules" -msgstr "" +msgstr "with-imported-modules" #. type: Plain text #: doc/guix.texi:5080 msgid "Another gexp feature is @dfn{imported modules}: sometimes you want to be able to use certain Guile modules from the ``host environment'' in the gexp, so those modules should be imported in the ``build environment''. The @code{with-imported-modules} form allows you to express that:" -msgstr "" +msgstr "Une autre fonctionnalité, ce sont les @dfn{modules importés} : parfois vous voudriez pouvoir utiliser certains modules Guile de « l'environnement hôte » dans la gexp, donc ces modules devraient être importés dans « l'environnement de construction ». La forme @code{with-imported-modules} vous permet d'exprimer ça :" #. type: example #: doc/guix.texi:5091 @@ -9702,28 +9791,37 @@ msgid "" " (display \"success!\\n\")\n" " #t)))\n" msgstr "" +"(let ((build (with-imported-modules '((guix build utils))\n" +" #~(begin\n" +" (use-modules (guix build utils))\n" +" (mkdir-p (string-append #$output \"/bin\"))))))\n" +" (gexp->derivation \"empty-dir\"\n" +" #~(begin\n" +" #$build\n" +" (display \"success!\\n\")\n" +" #t)))\n" #. type: Plain text #: doc/guix.texi:5097 msgid "In this example, the @code{(guix build utils)} module is automatically pulled into the isolated build environment of our gexp, such that @code{(use-modules (guix build utils))} works as expected." -msgstr "" +msgstr "Dans cet exemple, le module @code{(guix build utils)} est automatiquement récupéré dans l'environnement de construction isolé de notre gexp, pour que @code{(use-modules (guix build utils))} fonctionne comme on s'y attendrait." #. type: cindex #: doc/guix.texi:5098 #, no-wrap msgid "module closure" -msgstr "" +msgstr "closure de module" #. type: findex #: doc/guix.texi:5099 #, no-wrap msgid "source-module-closure" -msgstr "" +msgstr "source-module-closure" #. type: Plain text #: doc/guix.texi:5106 msgid "Usually you want the @emph{closure} of the module to be imported---i.e., the module itself and all the modules it depends on---rather than just the module; failing to do that, attempts to use the module will fail because of missing dependent modules. The @code{source-module-closure} procedure computes the closure of a module by looking at its source file headers, which comes in handy in this case:" -msgstr "" +msgstr "Typiquement, vous voudriez que la @emph{closure} complète du mondule soit importé — c.-à-d.@: le module lui-même et tous les modules dont il dépend — plutôt que seulement le module ; sinon, une tentative de chargement du module échouera à cause des modules dépendants manquants. La procédure @code{source-module-closure} calcule la closure d'un module en cherchant dans ses en-têtes sources, ce qui est pratique dans ce cas :" #. type: example #: doc/guix.texi:5109 @@ -9732,6 +9830,8 @@ msgid "" "(use-modules (guix modules)) ;for 'source-module-closure'\n" "\n" msgstr "" +"(use-modules (guix modules)) ;pour 'source-module-closure'\n" +"\n" #. type: example #: doc/guix.texi:5118 @@ -9746,23 +9846,31 @@ msgid "" " (gnu build vm))\n" " @dots{})))\n" msgstr "" +"(with-imported-modules (source-module-closure\n" +" '((guix build utils)\n" +" (gnu build vm)))\n" +" (gexp->derivation \"something-with-vms\"\n" +" #~(begin\n" +" (use-modules (guix build utils)\n" +" (gnu build vm))\n" +" @dots{})))\n" #. type: cindex #: doc/guix.texi:5120 #, no-wrap msgid "extensions, for gexps" -msgstr "" +msgstr "extensions, des gexps" #. type: findex #: doc/guix.texi:5121 #, no-wrap msgid "with-extensions" -msgstr "" +msgstr "with-extensions" #. type: Plain text #: doc/guix.texi:5126 msgid "In the same vein, sometimes you want to import not just pure-Scheme modules, but also ``extensions'' such as Guile bindings to C libraries or other ``full-blown'' packages. Say you need the @code{guile-json} package available on the build side, here's how you would do it:" -msgstr "" +msgstr "Dans la même idée, parfois vous pouvez souhaiter importer non seulement des modules en Scheme pur, mais aussi des « extensions » comme des liaisons Guile de bibliothèques C ou d'autres paquet « complets ». Disons que vous voulez utiliser le paquet @code{guile-json} du côté de la construction, voici comme procéder :" #. type: example #: doc/guix.texi:5129 @@ -9771,6 +9879,8 @@ msgid "" "(use-modules (gnu packages guile)) ;for 'guile-json'\n" "\n" msgstr "" +"(use-modules (gnu packages guile)) ;pour 'guile-json'\n" +"\n" #. type: example #: doc/guix.texi:5135 @@ -9782,183 +9892,188 @@ msgid "" " (use-modules (json))\n" " @dots{})))\n" msgstr "" +"(with-extensions (list guile-json)\n" +" (gexp->derivation \"something-with-json\"\n" +" #~(begin\n" +" (use-modules (json))\n" +" @dots{})))\n" #. type: Plain text #: doc/guix.texi:5138 msgid "The syntactic form to construct gexps is summarized below." -msgstr "" +msgstr "La forme syntaxique pour construire des gexps est résumée ci-dessous." #. type: deffn #: doc/guix.texi:5139 #, no-wrap msgid "{Scheme Syntax} #~@var{exp}" -msgstr "" +msgstr "{Syntaxe Scheme} #~@var{exp}" #. type: deffnx #: doc/guix.texi:5140 #, no-wrap msgid "{Scheme Syntax} (gexp @var{exp})" -msgstr "" +msgstr "{Syntaxe Scheme} (gexp @var{exp})" #. type: deffn #: doc/guix.texi:5143 msgid "Return a G-expression containing @var{exp}. @var{exp} may contain one or more of the following forms:" -msgstr "" +msgstr "Renvoie une G-expression contenant @var{exp}. @var{exp} peut contenir une ou plusieurs de ces formes :" #. type: item #: doc/guix.texi:5145 #, no-wrap msgid "#$@var{obj}" -msgstr "" +msgstr "#$@var{obj}" #. type: itemx #: doc/guix.texi:5146 #, no-wrap msgid "(ungexp @var{obj})" -msgstr "" +msgstr "(ungexp @var{obj})" #. type: table #: doc/guix.texi:5151 msgid "Introduce a reference to @var{obj}. @var{obj} may have one of the supported types, for example a package or a derivation, in which case the @code{ungexp} form is replaced by its output file name---e.g., @code{\"/gnu/store/@dots{}-coreutils-8.22}." -msgstr "" +msgstr "Introduit une référence à @var{obj}. @var{obj} peut être d'un des types supportés, par exemple un paquet ou une dérivation, auquel cas la forme @code{ungexp} est remplacée par le nom de fichier de sa sortie — p.@: ex.@: @code{\"/gnu/store/@dots{}-coreutils-8.22}." #. type: table #: doc/guix.texi:5154 msgid "If @var{obj} is a list, it is traversed and references to supported objects are substituted similarly." -msgstr "" +msgstr "Si @var{boj} est une liste, elle est traversée et les références aux objets supportés sont substitués de manière similaire." #. type: table #: doc/guix.texi:5157 msgid "If @var{obj} is another gexp, its contents are inserted and its dependencies are added to those of the containing gexp." -msgstr "" +msgstr "Si @var{obj} est une autre gexp, son contenu est inséré et ses dépendances sont ajoutées à celle de la gexp qui l'entoure." #. type: table #: doc/guix.texi:5159 msgid "If @var{obj} is another kind of object, it is inserted as is." -msgstr "" +msgstr "Si @var{obj} est un autre type d'objet, il est inséré tel quel." #. type: item #: doc/guix.texi:5160 #, no-wrap msgid "#$@var{obj}:@var{output}" -msgstr "" +msgstr "#$@var{obj}:@var{output}" #. type: itemx #: doc/guix.texi:5161 #, no-wrap msgid "(ungexp @var{obj} @var{output})" -msgstr "" +msgstr "(ungexp @var{obj} @var{output})" #. type: table #: doc/guix.texi:5165 msgid "This is like the form above, but referring explicitly to the @var{output} of @var{obj}---this is useful when @var{obj} produces multiple outputs (@pxref{Packages with Multiple Outputs})." -msgstr "" +msgstr "Cette forme est similaire à la précédente, mais se réfère explicitement à la sortie @var{output} de l'objet @var{obj} — c'est utile lorsque @var{obj} produit plusieurs sorties (@pxref{Packages with Multiple Outputs})." #. type: item #: doc/guix.texi:5166 #, no-wrap msgid "#+@var{obj}" -msgstr "" +msgstr "#+@var{obj}" #. type: itemx #: doc/guix.texi:5167 #, no-wrap msgid "#+@var{obj}:output" -msgstr "" +msgstr "#+@var{obj}:output" #. type: itemx #: doc/guix.texi:5168 #, no-wrap msgid "(ungexp-native @var{obj})" -msgstr "" +msgstr "(ungexp-native @var{obj})" #. type: itemx #: doc/guix.texi:5169 #, no-wrap msgid "(ungexp-native @var{obj} @var{output})" -msgstr "" +msgstr "(ungexp-native @var{obj} @var{output})" #. type: table #: doc/guix.texi:5172 msgid "Same as @code{ungexp}, but produces a reference to the @emph{native} build of @var{obj} when used in a cross compilation context." -msgstr "" +msgstr "Comme @code{ungexp}, mais produit une référence à la construction @emph{native} de @var{obj} lorsqu'elle est utilisée dans une compilation croisée." #. type: item #: doc/guix.texi:5173 #, no-wrap msgid "#$output[:@var{output}]" -msgstr "" +msgstr "#$output[:@var{output}]" #. type: itemx #: doc/guix.texi:5174 #, no-wrap msgid "(ungexp output [@var{output}])" -msgstr "" +msgstr "(ungexp output [@var{output}])" #. type: table #: doc/guix.texi:5177 msgid "Insert a reference to derivation output @var{output}, or to the main output when @var{output} is omitted." -msgstr "" +msgstr "Insère une référence à la sortie @var{output} de la dérivation, ou à la sortie principale lorsque @var{output} est omis." #. type: table #: doc/guix.texi:5179 msgid "This only makes sense for gexps passed to @code{gexp->derivation}." -msgstr "" +msgstr "Cela ne fait du sens que pour les gexps passées à @code{gexp->derivation}." #. type: item #: doc/guix.texi:5180 #, no-wrap msgid "#$@@@var{lst}" -msgstr "" +msgstr "#$@@@var{lst}" #. type: itemx #: doc/guix.texi:5181 #, no-wrap msgid "(ungexp-splicing @var{lst})" -msgstr "" +msgstr "(ungexp-splicing @var{lst})" #. type: table #: doc/guix.texi:5184 msgid "Like the above, but splices the contents of @var{lst} inside the containing list." -msgstr "" +msgstr "Comme au dessus, mais recolle (@i{splice}) le contenu de @var{lst} dans la liste qui la contient." #. type: item #: doc/guix.texi:5185 #, no-wrap msgid "#+@@@var{lst}" -msgstr "" +msgstr "#+@@@var{lst}" #. type: itemx #: doc/guix.texi:5186 #, no-wrap msgid "(ungexp-native-splicing @var{lst})" -msgstr "" +msgstr "(ungexp-native-splicing @var{lst})" #. type: table #: doc/guix.texi:5189 msgid "Like the above, but refers to native builds of the objects listed in @var{lst}." -msgstr "" +msgstr "Comme au dessus, mais se réfère à la construction native des objets listés dans @var{lst}." #. type: deffn #: doc/guix.texi:5194 msgid "G-expressions created by @code{gexp} or @code{#~} are run-time objects of the @code{gexp?} type (see below.)" -msgstr "" +msgstr "Les G-expressions crées par @code{gexp} ou @code{#~} sont des objets à l'exécution du type @code{gexp?} (voir plus bas)." #. type: deffn #: doc/guix.texi:5196 #, no-wrap msgid "{Scheme Syntax} with-imported-modules @var{modules} @var{body}@dots{}" -msgstr "" +msgstr "{Syntaxe Scheme} with-imported-modules @var{modules} @var{body}@dots{}" #. type: deffn #: doc/guix.texi:5199 msgid "Mark the gexps defined in @var{body}@dots{} as requiring @var{modules} in their execution environment." -msgstr "" +msgstr "Marque les gexps définies dans @var{body}@dots{} comme requérant @var{modules} dans leur environnement d'exécution." #. type: deffn #: doc/guix.texi:5203 msgid "Each item in @var{modules} can be the name of a module, such as @code{(guix build utils)}, or it can be a module name, followed by an arrow, followed by a file-like object:" -msgstr "" +msgstr "Chaque élément dans @var{module} peut être le nom d'un module, comme @code{(guix build utils)} ou le nom d'un module suivi d'une flêche, suivie d'un objet simili-fichier :" #. type: example #: doc/guix.texi:5209 @@ -9969,79 +10084,95 @@ msgid "" " ((guix config) => ,(scheme-file \"config.scm\"\n" " #~(define-module @dots{}))))\n" msgstr "" +"`((guix build utils)\n" +" (guix gcrypt)\n" +" ((guix config) => ,(scheme-file \"config.scm\"\n" +" #~(define-module @dots{}))))\n" #. type: deffn #: doc/guix.texi:5214 msgid "In the example above, the first two modules are taken from the search path, and the last one is created from the given file-like object." -msgstr "" +msgstr "Dans l'exemple au dessus, les deux premiers modules sont récupérés dans le chemin de recherche, et le dernier est créé à partir d'un objet simili-fichier." #. type: deffn #: doc/guix.texi:5218 msgid "This form has @emph{lexical} scope: it has an effect on the gexps directly defined in @var{body}@dots{}, but not on those defined, say, in procedures called from @var{body}@dots{}." -msgstr "" +msgstr "Cette forme a une portée @emph{lexicale} : elle a un effet sur les gexp directement définies dans @var{body}@dots{}, mais pas sur celles définies dans des procédures appelées par @var{body}@dots{}." #. type: deffn #: doc/guix.texi:5220 #, no-wrap msgid "{Scheme Syntax} with-extensions @var{extensions} @var{body}@dots{}" -msgstr "" +msgstr "{Syntaxe Scheme} with-extensions @var{extensions} @var{body}@dots{}" #. type: deffn #: doc/guix.texi:5225 msgid "Mark the gexps defined in @var{body}@dots{} as requiring @var{extensions} in their build and execution environment. @var{extensions} is typically a list of package objects such as those defined in the @code{(gnu packages guile)} module." -msgstr "" +msgstr "Marque les gexps définies dans @var{body}@dots{} comme requérant @var{extensions} dans leur environnement de construction et d'exécution. @var{extensions} est typiquement une liste d'objets paquets comme définis dans le module @code{(gnu packages guile)}." #. type: deffn #: doc/guix.texi:5230 msgid "Concretely, the packages listed in @var{extensions} are added to the load path while compiling imported modules in @var{body}@dots{}; they are also added to the load path of the gexp returned by @var{body}@dots{}." -msgstr "" +msgstr "Concrètement, les paquets listés dans @var{extensions} sont ajoutés au chemin de chargement lors de la compilation des modules importés dans @var{body}@dots{} ; ils sont aussi ajoutés au chemin de chargement de la gexp renvoyée par @var{body}@dots{}." #. type: deffn #: doc/guix.texi:5232 #, no-wrap msgid "{Scheme Procedure} gexp? @var{obj}" -msgstr "" +msgstr "{Procédure Scheme} gexp? @var{obj}" #. type: deffn #: doc/guix.texi:5234 msgid "Return @code{#t} if @var{obj} is a G-expression." -msgstr "" +msgstr "Renvoie @code{#t} si @var{obj} est une G-expression." #. type: Plain text #: doc/guix.texi:5240 msgid "G-expressions are meant to be written to disk, either as code building some derivation, or as plain files in the store. The monadic procedures below allow you to do that (@pxref{The Store Monad}, for more information about monads.)" -msgstr "" +msgstr "Les G-expressions sont conçues pour être écrites sur le disque, soit en tant que code pour construire une dérivation, soit en tant que fichier normal dans le dépôt. Les procédure monadiques suivantes vous permettent de faire cela (@pxref{The Store Monad}, pour plus d'information sur les monads)." #. type: deffn #: doc/guix.texi:5241 #, no-wrap msgid "{Monadic Procedure} gexp->derivation @var{name} @var{exp} @" -msgstr "" +msgstr "{Procédure Monadique} gexp->derivation @var{name} @var{exp} @" #. type: deffn #: doc/guix.texi:5258 msgid "[#:system (%current-system)] [#:target #f] [#:graft? #t] @ [#:hash #f] [#:hash-algo #f] @ [#:recursive? #f] [#:env-vars '()] [#:modules '()] @ [#:module-path @var{%load-path}] @ [#:effective-version \"2.2\"] @ [#:references-graphs #f] [#:allowed-references #f] @ [#:disallowed-references #f] @ [#:leaked-env-vars #f] @ [#:script-name (string-append @var{name} \"-builder\")] @ [#:deprecation-warnings #f] @ [#:local-build? #f] [#:substitutable? #t] [#:guile-for-build #f] Return a derivation @var{name} that runs @var{exp} (a gexp) with @var{guile-for-build} (a derivation) on @var{system}; @var{exp} is stored in a file called @var{script-name}. When @var{target} is true, it is used as the cross-compilation target triplet for packages referred to by @var{exp}." msgstr "" +"[#:system (%current-system)] [#:target #f] [#:graft? #t] @\n" +"[#:hash #f] [#:hash-algo #f] @\n" +"[#:recursive? #f] [#:env-vars '()] [#:modules '()] @\n" +"[#:module-path @var{%load-path}] @\n" +"[#:effective-version \"2.2\"] @\n" +"[#:references-graphs #f] [#:allowed-references #f] @\n" +"[#:disallowed-references #f] @\n" +"[#:leaked-env-vars #f] @\n" +"[#:script-name (string-append @var{name} \"-builder\")] @\n" +"[#:deprecation-warnings #f] @\n" +"[#:local-build? #f] [#:substitutable? #t] [#:guile-for-build #f]\n" +"Renvoie une dérivation @var{name} qui lance @var{exp} (une gexp) avec @var{guile-for-build} (une dérivation) sur @var{system} ; @var{exp} est stocké dans un fichier appelé @var{script-name}. Lorsque @var{target} est vraie, elle est utilisée comme triplet de cible de compilation croisée pour les paquets référencés par @var{exp}." #. type: deffn #: doc/guix.texi:5266 msgid "@var{modules} is deprecated in favor of @code{with-imported-modules}. Its meaning is to make @var{modules} available in the evaluation context of @var{exp}; @var{modules} is a list of names of Guile modules searched in @var{module-path} to be copied in the store, compiled, and made available in the load path during the execution of @var{exp}---e.g., @code{((guix build utils) (guix build gnu-build-system))}." -msgstr "" +msgstr "@var{modules} est devenu obsolète en faveur de @code{with-imported-modules}. Sa signification est de rendre @var{modules} disponibles dans le contexte d'évaluation de @var{exp} ; @var{modules} est une liste de noms de modules Guile qui sont cherchés dans @var{module-path} pour les copier dans le dépôt, les compiler et les rendre disponibles dans le chemin de chargement pendant l'exécution de @var{exp} — p.@: ex.@: @code{((guix build utils) (guix build gnu-build-system))}." #. type: deffn #: doc/guix.texi:5269 msgid "@var{effective-version} determines the string to use when adding extensions of @var{exp} (see @code{with-extensions}) to the search path---e.g., @code{\"2.2\"}." -msgstr "" +msgstr "@var{effective-version} détermine la chaîne à utiliser lors d'ajout d'extensions de @var{exp} (voir @code{with-extensions}) au chemin de recherche — p.@: ex.@: @code{\"2.2\"}." #. type: deffn #: doc/guix.texi:5272 msgid "@var{graft?} determines whether packages referred to by @var{exp} should be grafted when applicable." -msgstr "" +msgstr "@var{graft?} détermine si les paquets référencés par @var{exp} devraient être greffés si possible." #. type: deffn #: doc/guix.texi:5275 msgid "When @var{references-graphs} is true, it must be a list of tuples of one of the following forms:" -msgstr "" +msgstr "Lorsque @var{references-graphs} est vrai, il doit s'agir d'une liste de tuples de la forme suivante :" #. type: example #: doc/guix.texi:5282 @@ -10053,37 +10184,42 @@ msgid "" "(@var{file-name} @var{derivation} @var{output})\n" "(@var{file-name} @var{store-item})\n" msgstr "" +"(@var{file-name} @var{package})\n" +"(@var{file-name} @var{package} @var{output})\n" +"(@var{file-name} @var{derivation})\n" +"(@var{file-name} @var{derivation} @var{output})\n" +"(@var{file-name} @var{store-item})\n" #. type: deffn #: doc/guix.texi:5288 msgid "The right-hand-side of each element of @var{references-graphs} is automatically made an input of the build process of @var{exp}. In the build environment, each @var{file-name} contains the reference graph of the corresponding item, in a simple text format." -msgstr "" +msgstr "La partie droite des éléments de @var{references-graphs} est automatiquement transformée en une entrée du processus de construction @var{exp}. Dans l'environnement de construction, chaque @var{file-name} contient le graphe des références de l'élément correspondant, dans un format texte simple." #. type: deffn #: doc/guix.texi:5294 msgid "@var{allowed-references} must be either @code{#f} or a list of output names and packages. In the latter case, the list denotes store items that the result is allowed to refer to. Any reference to another store item will lead to a build error. Similarly for @var{disallowed-references}, which can list items that must not be referenced by the outputs." -msgstr "" +msgstr "@var{allowed-references} doit soit être @code{#f}, soit une liste de noms de sorties ou de paquets. Dans ce dernier cas, la liste dénote les éléments du dépôt auxquels le résultat a le droit de faire référence. Toute référence à un autre élément du dépôt conduira à une erreur à la construction. Comme pour @var{disallowed-references}, qui peut lister des éléments qui ne doivent pas être référencés par les sorties." #. type: deffn #: doc/guix.texi:5297 msgid "@var{deprecation-warnings} determines whether to show deprecation warnings while compiling modules. It can be @code{#f}, @code{#t}, or @code{'detailed}." -msgstr "" +msgstr "@var{deprecation-warnings} détermine s'il faut afficher les avertissement d'obsolescence à la compilation de modules. Il peut valoir @code{#f}, @code{t} ou @code{'detailed}." #. type: deffn #: doc/guix.texi:5299 msgid "The other arguments are as for @code{derivation} (@pxref{Derivations})." -msgstr "" +msgstr "Les autres arguments sont les mêmes que pour @code{derivation} (@pxref{Derivations})." #. type: cindex #: doc/guix.texi:5301 #, no-wrap msgid "file-like objects" -msgstr "" +msgstr "objets simili-fichiers" #. type: Plain text #: doc/guix.texi:5306 msgid "The @code{local-file}, @code{plain-file}, @code{computed-file}, @code{program-file}, and @code{scheme-file} procedures below return @dfn{file-like objects}. That is, when unquoted in a G-expression, these objects lead to a file in the store. Consider this G-expression:" -msgstr "" +msgstr "Les procédures @code{local-file}, @code{plain-file}, @code{computed-file}, @code{program-file} et @code{scheme-file} ci-dessous renvoient des @dfn{objets simili-fichiers}. C'est-à-dire, lorsqu'ils sont unquotés dans une G-expression, ces objets donnent un fichier dans le dépôt. Considérez cette G-expression :" #. type: example #: doc/guix.texi:5310 @@ -10092,75 +10228,83 @@ msgid "" "#~(system* #$(file-append glibc \"/sbin/nscd\") \"-f\"\n" " #$(local-file \"/tmp/my-nscd.conf\"))\n" msgstr "" +"#~(system* #$(file-append glibc \"/sbin/nscd\") \"-f\"\n" +" #$(local-file \"/tmp/my-nscd.conf\"))\n" #. type: Plain text #: doc/guix.texi:5319 msgid "The effect here is to ``intern'' @file{/tmp/my-nscd.conf} by copying it to the store. Once expanded, for instance @i{via} @code{gexp->derivation}, the G-expression refers to that copy under @file{/gnu/store}; thus, modifying or removing the file in @file{/tmp} does not have any effect on what the G-expression does. @code{plain-file} can be used similarly; it differs in that the file content is directly passed as a string." -msgstr "" +msgstr "Ici, l'effet est « d'internaliser » @file{/tmp/my-nscd.conf} en le copiant dans le dépôt. Une fois étendu, par exemple via @code{gexp->derivation}, la G-expression se réfère à cette copie dans @file{/gnu/store} ; ainsi, modifier ou supprimer le fichier dans @file{/tmp} n'a aucun effet sur ce que fait la G-expression. @code{plain-file} peut être utilisé de la même manière ; elle est seulement différente par le fait que le contenu du fichier est passé directement par une chaîne de caractères." #. type: deffn #: doc/guix.texi:5320 #, no-wrap msgid "{Scheme Procedure} local-file @var{file} [@var{name}] @" -msgstr "" +msgstr "{Procédure Scheme} local-file @var{file} [@var{name}] @" #. type: deffn #: doc/guix.texi:5326 msgid "[#:recursive? #f] [#:select? (const #t)] Return an object representing local file @var{file} to add to the store; this object can be used in a gexp. If @var{file} is a relative file name, it is looked up relative to the source file where this form appears. @var{file} will be added to the store under @var{name}--by default the base name of @var{file}." msgstr "" +"[#:recursive? #f] [#:select? (const #t)]\n" +"Renvoie un objet représentant un fichier local @var{file} à ajouter au dépôt ; cet objet peut être utilisé dans une gexp. Si @var{file} est un nom de fichier relatif, il est récupéré à partir de la position du fichier source dans lequel il apparaît. @var{file} sera ajouté au dépôt sous le nom @var{name} — par défaut le nom de base de @var{file}." #. type: deffn #: doc/guix.texi:5338 msgid "This is the declarative counterpart of the @code{interned-file} monadic procedure (@pxref{The Store Monad, @code{interned-file}})." -msgstr "" +msgstr "C'est la version déclarative de la procédure monadique @code{interned-file} (@pxref{The Store Monad, @code{interned-file}})." #. type: deffn #: doc/guix.texi:5340 #, no-wrap msgid "{Scheme Procedure} plain-file @var{name} @var{content}" -msgstr "" +msgstr "{Procédure Scheme} plain-file @var{name} @var{content}" #. type: deffn #: doc/guix.texi:5343 msgid "Return an object representing a text file called @var{name} with the given @var{content} (a string) to be added to the store." -msgstr "" +msgstr "Renvoie un objet représentant un fichier texte nommé @var{name} avec pour contenu @var{content} (une chaîne de caractères) à ajouter un dépôt." #. type: deffn #: doc/guix.texi:5345 msgid "This is the declarative counterpart of @code{text-file}." -msgstr "" +msgstr "C'est la version déclarative de @code{text-file}." #. type: deffn #: doc/guix.texi:5347 #, no-wrap msgid "{Scheme Procedure} computed-file @var{name} @var{gexp} @" -msgstr "" +msgstr "{Procédure Scheme} computed-file @var{name} @var{gexp} @" #. type: deffn #: doc/guix.texi:5352 msgid "[#:options '(#:local-build? #t)] Return an object representing the store item @var{name}, a file or directory computed by @var{gexp}. @var{options} is a list of additional arguments to pass to @code{gexp->derivation}." msgstr "" +"[#:options '(#:local-build? #t)]\n" +"Renvoie un objet représentant un élément du dépôt @var{name}, un fichier ou un répertoire calculé par @var{gexp}. @var{options} est une liste d'arguments supplémentaires à passer à @code{gexp->derivation}." #. type: deffn #: doc/guix.texi:5354 msgid "This is the declarative counterpart of @code{gexp->derivation}." -msgstr "" +msgstr "C'est la version déclarative de @code{gexp->derivation}." #. type: deffn #: doc/guix.texi:5356 #, no-wrap msgid "{Monadic Procedure} gexp->script @var{name} @var{exp} @" -msgstr "" +msgstr "{Procédure monadique} gexp->script @var{name} @var{exp} @" #. type: deffn #: doc/guix.texi:5361 msgid "[#:guile (default-guile)] [#:module-path %load-path] Return an executable script @var{name} that runs @var{exp} using @var{guile}, with @var{exp}'s imported modules in its search path. Look up @var{exp}'s modules in @var{module-path}." msgstr "" +"[#:guile (default-guile)] [#:module-path %load-path]\n" +"Renvoie un script exécutable @var{name} qui lance @var{exp} avec @var{guile}, avec les modules importés de @var{exp} dans son chemin de recherche. Cherche les modules de @var{exp} dans @var{module-path}." #. type: deffn #: doc/guix.texi:5364 msgid "The example below builds a script that simply invokes the @command{ls} command:" -msgstr "" +msgstr "L'exemple ci-dessous construit un script qui invoque simplement la commande @command{ls} :" #. type: example #: doc/guix.texi:5367 @@ -10169,6 +10313,8 @@ msgid "" "(use-modules (guix gexp) (gnu packages base))\n" "\n" msgstr "" +"(use-modules (guix gexp) (gnu packages base))\n" +"\n" #. type: example #: doc/guix.texi:5371 @@ -10178,11 +10324,14 @@ msgid "" " #~(execl #$(file-append coreutils \"/bin/ls\")\n" " \"ls\"))\n" msgstr "" +"(gexp->script \"list-files\"\n" +" #~(execl #$(file-append coreutils \"/bin/ls\")\n" +" \"ls\"))\n" #. type: deffn #: doc/guix.texi:5376 msgid "When ``running'' it through the store (@pxref{The Store Monad, @code{run-with-store}}), we obtain a derivation that produces an executable file @file{/gnu/store/@dots{}-list-files} along these lines:" -msgstr "" +msgstr "Lorsqu'elle est « lancée » à travers le dépôt (@pxref{The Store Monad, @code{run-with-store}}), on obtient une dérivation qui produit une fichier exécutable @file{/gnu/store/@dots{}-list-files} qui ressemble à :" #. type: example #: doc/guix.texi:5381 @@ -10192,75 +10341,84 @@ msgid "" "!#\n" "(execl \"/gnu/store/@dots{}-coreutils-8.22\"/bin/ls\" \"ls\")\n" msgstr "" +"#!/gnu/store/@dots{}-guile-2.0.11/bin/guile -ds\n" +"!#\n" +"(execl \"/gnu/store/@dots{}-coreutils-8.22\"/bin/ls\" \"ls\")\n" #. type: deffn #: doc/guix.texi:5384 #, no-wrap msgid "{Scheme Procedure} program-file @var{name} @var{exp} @" -msgstr "" +msgstr "{Procédure Scheme} program-file @var{name} @var{exp} @" #. type: deffn #: doc/guix.texi:5389 msgid "[#:guile #f] [#:module-path %load-path] Return an object representing the executable store item @var{name} that runs @var{gexp}. @var{guile} is the Guile package used to execute that script. Imported modules of @var{gexp} are looked up in @var{module-path}." msgstr "" +"[#:guile #f] [#:module-path %load-path]\n" +"Renvoie un objet représentant un élément du dépôt @var{name} qui lance @var{gexp}. @var{guile} est le paquet Guile à utiliser pour exécuter le script. Les modules importés par @var{gexp} sont recherchés dans @var{module-path}." #. type: deffn #: doc/guix.texi:5391 msgid "This is the declarative counterpart of @code{gexp->script}." -msgstr "" +msgstr "C'est la version déclarative de @code{gexp->script}." #. type: deffn #: doc/guix.texi:5393 #, no-wrap msgid "{Monadic Procedure} gexp->file @var{name} @var{exp} @" -msgstr "" +msgstr "{Procédure monadique} gexp->file @var{name} @var{exp} @" #. type: deffn #: doc/guix.texi:5400 msgid "[#:set-load-path? #t] [#:module-path %load-path] @ [#:splice? #f] @ [#:guile (default-guile)] Return a derivation that builds a file @var{name} containing @var{exp}. When @var{splice?} is true, @var{exp} is considered to be a list of expressions that will be spliced in the resulting file." msgstr "" +"[#:set-load-path? #t] [#:module-path %load-path] @\n" +"[#:splice? #f] @\n" +"[#:guile (default-guile)]\n" +"Renvoie une dérivation qui construit un fichier @var{name} contenant @var{exp}. Lorsque @var{splice?} est vrai, @var{exp} est considéré comme une liste d'expressions qui seront splicée dans le fichier qui en résulte." #. type: deffn #: doc/guix.texi:5405 msgid "When @var{set-load-path?} is true, emit code in the resulting file to set @code{%load-path} and @code{%load-compiled-path} to honor @var{exp}'s imported modules. Look up @var{exp}'s modules in @var{module-path}." -msgstr "" +msgstr "Lorsque @var{set-load-path?} est vrai, émet du code dans le fichier de résultat pour initialiser @code{%load-path} et @code{%load-compiled-path} pour honorer les modules importés de @var{exp}. Les modules de @var{exp} sont trouvés dans @var{module-path}." #. type: deffn #: doc/guix.texi:5408 msgid "The resulting file holds references to all the dependencies of @var{exp} or a subset thereof." -msgstr "" +msgstr "Le fichier qui en résulte retient les références à toutes les dépendances de @var{exp} ou un sous-ensemble." #. type: deffn #: doc/guix.texi:5410 #, no-wrap msgid "{Scheme Procedure} scheme-file @var{name} @var{exp} [#:splice? #f]" -msgstr "{Scheme Procedure} derivation @var{store} @var{name} @var{builder} @" +msgstr "{Procédure Scheme} scheme-file @var{name} @var{exp} [#:splice? #f]" #. type: deffn #: doc/guix.texi:5413 msgid "Return an object representing the Scheme file @var{name} that contains @var{exp}." -msgstr "" +msgstr "Renvoie un objet représentant le fichier Scheme @var{name} qui contient @var{exp}." #. type: deffn #: doc/guix.texi:5415 msgid "This is the declarative counterpart of @code{gexp->file}." -msgstr "" +msgstr "C'est la version déclarative de @code{gexp->file}." #. type: deffn #: doc/guix.texi:5417 #, no-wrap msgid "{Monadic Procedure} text-file* @var{name} @var{text} @dots{}" -msgstr "" +msgstr "{Procédure monadique} text-file* @var{name} @var{text} @dots{}" #. type: deffn #: doc/guix.texi:5423 msgid "Return as a monadic value a derivation that builds a text file containing all of @var{text}. @var{text} may list, in addition to strings, objects of any type that can be used in a gexp: packages, derivations, local file objects, etc. The resulting store file holds references to all these." -msgstr "" +msgstr "Renvoie une valeur monadique qui construit un ficher texte contenant @var{text}. @var{text} peut lister, en plus de chaînes de caractères, des objet de n'importe quel type qui peut être utilisé dans une gexp : des paquets, des dérivations, des fichiers objet locaux, etc. Le fichier du dépôt qui en résulte en retient toutes les références." #. type: deffn #: doc/guix.texi:5428 msgid "This variant should be preferred over @code{text-file} anytime the file to create will reference items from the store. This is typically the case when building a configuration file that embeds store file names, like this:" -msgstr "" +msgstr "Cette variante devrait être préférée à @code{text-file} lorsque vous souhaitez créer des fichiers qui référencent le dépôt. Cela est le cas typiquement lorsque vous construisez un fichier de configuration qui contient des noms de fichiers du dépôt, comme ceci :" #. type: example #: doc/guix.texi:5436 @@ -10273,22 +10431,28 @@ msgid "" " \"export PATH=\" coreutils \"/bin:\"\n" " grep \"/bin:\" sed \"/bin\\n\"))\n" msgstr "" +"(define (profile.sh)\n" +" ;; Renvoie le nom d'un script shell dans le dépôt qui initialise\n" +" ;; la variable d'environnement « PATH ».\n" +" (text-file* \"profile.sh\"\n" +" \"export PATH=\" coreutils \"/bin:\"\n" +" grep \"/bin:\" sed \"/bin\\n\"))\n" #. type: deffn #: doc/guix.texi:5441 msgid "In this example, the resulting @file{/gnu/store/@dots{}-profile.sh} file will reference @var{coreutils}, @var{grep}, and @var{sed}, thereby preventing them from being garbage-collected during its lifetime." -msgstr "" +msgstr "Dans cet exemple, le fichier @file{/gnu/store/@dots{}-profile.sh} qui en résulte référence @var{coreutils}, @var{grep} et @var{sed}, ce qui les empêche d'être glanés tant que le script est accessible." #. type: deffn #: doc/guix.texi:5443 #, no-wrap msgid "{Scheme Procedure} mixed-text-file @var{name} @var{text} @dots{}" -msgstr "" +msgstr "{Procédure Scheme} mixed-text-file @var{name} @var{text} @dots{}" #. type: deffn #: doc/guix.texi:5447 msgid "Return an object representing store file @var{name} containing @var{text}. @var{text} is a sequence of strings and file-like objects, as in:" -msgstr "" +msgstr "Renvoie un objet représentant le fichier du dépôt @var{name} contenant @var{text}. @var{text} est une séquence de chaînes de caractères et de fichiers simili-objets, comme dans :" #. type: example #: doc/guix.texi:5451 @@ -10297,22 +10461,24 @@ msgid "" "(mixed-text-file \"profile\"\n" " \"export PATH=\" coreutils \"/bin:\" grep \"/bin\")\n" msgstr "" +"(mixed-text-file \"profile\"\n" +" \"export PATH=\" coreutils \"/bin:\" grep \"/bin\")\n" #. type: deffn #: doc/guix.texi:5454 msgid "This is the declarative counterpart of @code{text-file*}." -msgstr "" +msgstr "C'est la version déclarative de @code{text-file*}." #. type: deffn #: doc/guix.texi:5456 #, no-wrap msgid "{Scheme Procedure} file-union @var{name} @var{files}" -msgstr "" +msgstr "{Procédure Scheme} file-union @var{name} @var{files}" #. type: deffn #: doc/guix.texi:5461 msgid "Return a @code{} that builds a directory containing all of @var{files}. Each item in @var{files} must be a two-element list where the first element is the file name to use in the new directory, and the second element is a gexp denoting the target file. Here's an example:" -msgstr "" +msgstr "Renvoie un @code{} qui construit un répertoire qui contient tous les fichiers de @var{files}. Chaque élément de @var{files} doit être une paire où le premier élément est le nom de fichier à utiliser dans le nouveau répertoire et le second élément est une gexp dénotant le fichier cible. Voici un exemple :" #. type: example #: doc/guix.texi:5468 @@ -10324,49 +10490,54 @@ msgid "" " (\"bashrc\" ,(plain-file \"bashrc\"\n" " \"alias ls='ls --color'\"))))\n" msgstr "" +"(file-union \"etc\"\n" +" `((\"hosts\" ,(plain-file \"hosts\"\n" +" \"127.0.0.1 localhost\"))\n" +" (\"bashrc\" ,(plain-file \"bashrc\"\n" +" \"alias ls='ls --color'\"))))\n" #. type: deffn #: doc/guix.texi:5471 msgid "This yields an @code{etc} directory containing these two files." -msgstr "" +msgstr "Cela crée un répertoire @code{etc} contenant ces deux fichiers." #. type: deffn #: doc/guix.texi:5473 #, no-wrap msgid "{Scheme Procedure} directory-union @var{name} @var{things}" -msgstr "" +msgstr "{Procédure Scheme} directory-union @var{name} @var{things}" #. type: deffn #: doc/guix.texi:5476 msgid "Return a directory that is the union of @var{things}, where @var{things} is a list of file-like objects denoting directories. For example:" -msgstr "" +msgstr "Renvoie un répertoire qui est l'union de @var{things}, où @var{things} est une liste d'objets simili-fichiers qui dénotent des répertoires. Par exemple :" #. type: example #: doc/guix.texi:5479 #, no-wrap msgid "(directory-union \"guile+emacs\" (list guile emacs))\n" -msgstr "" +msgstr "(directory-union \"guile+emacs\" (list guile emacs))\n" #. type: deffn #: doc/guix.texi:5482 msgid "yields a directory that is the union of the @code{guile} and @code{emacs} packages." -msgstr "" +msgstr "crée un répertoire qui est l'union des paquets @code{guile} et @code{emacs}." #. type: deffn #: doc/guix.texi:5484 #, no-wrap msgid "{Scheme Procedure} file-append @var{obj} @var{suffix} @dots{}" -msgstr "" +msgstr "{Procédure Scheme} file-append @var{obj} @var{suffix} @dots{}" #. type: deffn #: doc/guix.texi:5488 msgid "Return a file-like object that expands to the concatenation of @var{obj} and @var{suffix}, where @var{obj} is a lowerable object and each @var{suffix} is a string." -msgstr "" +msgstr "Renvoie un objet simili-fichier qui correspond à la concaténation de @var{obj} et @var{suffix} où @var{obj} est un objet abaissable et chaque @var{suffix} est une chaîne de caractères." #. type: deffn #: doc/guix.texi:5490 msgid "As an example, consider this gexp:" -msgstr "" +msgstr "Par exemple, considérez cette gexp :" #. type: example #: doc/guix.texi:5495 @@ -10376,11 +10547,14 @@ msgid "" " #~(system* #$(file-append coreutils\n" " \"/bin/uname\")))\n" msgstr "" +"(gexp->script \"run-uname\"\n" +" #~(system* #$(file-append coreutils\n" +" \"/bin/uname\")))\n" #. type: deffn #: doc/guix.texi:5498 msgid "The same effect could be achieved with:" -msgstr "" +msgstr "On peut obtenir le même effet avec :" #. type: example #: doc/guix.texi:5503 @@ -10390,32 +10564,37 @@ msgid "" " #~(system* (string-append #$coreutils\n" " \"/bin/uname\")))\n" msgstr "" +"(gexp->script \"run-uname\"\n" +" #~(system* (string-append #$coreutils\n" +" \"/bin/uname\")))\n" #. type: deffn #: doc/guix.texi:5509 msgid "There is one difference though: in the @code{file-append} case, the resulting script contains the absolute file name as a string, whereas in the second case, the resulting script contains a @code{(string-append @dots{})} expression to construct the file name @emph{at run time}." -msgstr "" +msgstr "Il y a une différence cependant : dans le cas @code{file-append}, le script qui en résulte contient le nom de fichier absolu comme une chaîne de caractère alors que dans le deuxième cas, le script contient une expression @code{(string-append @dots{})} pour construire le nom de fichier @emph{à l'exécution}." #. type: Plain text #: doc/guix.texi:5516 msgid "Of course, in addition to gexps embedded in ``host'' code, there are also modules containing build tools. To make it clear that they are meant to be used in the build stratum, these modules are kept in the @code{(guix build @dots{})} name space." -msgstr "" +msgstr "Bien sûr, en plus de gexps inclues dans le code « hôte », certains modules contiennent des outils de construction. Pour savoir facilement qu'ils sont à utiliser dans la strate de construction, ces modules sont gardés dans l'espace de nom @code{(guix build @dots{})}." #. type: Plain text #: doc/guix.texi:5522 msgid "Internally, high-level objects are @dfn{lowered}, using their compiler, to either derivations or store items. For instance, lowering a package yields a derivation, and lowering a @code{plain-file} yields a store item. This is achieved using the @code{lower-object} monadic procedure." -msgstr "" +msgstr "En interne, les objets de haut-niveau sont @dfn{abaissés}, avec leur compilateur, soit en des dérivations, soit en des objets du dépôt. Par exemple, abaisser un paquet crée une dérivation, et abaisser un @code{plain-file} crée un élément du dépôt. Cela est effectué par la procédure monadique @code{lower-object}." #. type: deffn #: doc/guix.texi:5523 #, no-wrap msgid "{Monadic Procedure} lower-object @var{obj} [@var{system}] @" -msgstr "" +msgstr "{Procédure Monadique} lower-object @var{obj} [@var{system}] @" #. type: deffn #: doc/guix.texi:5529 msgid "[#:target #f] Return as a value in @var{%store-monad} the derivation or store item corresponding to @var{obj} for @var{system}, cross-compiling for @var{target} if @var{target} is true. @var{obj} must be an object that has an associated gexp compiler, such as a @code{}." msgstr "" +"[#:target #f]\n" +"Renvoie la dérivation ou l'élément du dépôt comme une valeur de @var{%store-monad} qui correspond à @var{obj} pour @var{system}, en compilant de manière croisée pour @var{target} si @var{target} est vrai. @var{obj} doit être un objet qui a un compilateur de gexp associé, comme un @code{}." #. type: Plain text #: doc/guix.texi:5540 @@ -10437,7 +10616,7 @@ msgstr "guix build" #. type: Plain text #: doc/guix.texi:5569 msgid "The @command{guix build} command builds packages or derivations and their dependencies, and prints the resulting store paths. Note that it does not modify the user's profile---this is the job of the @command{guix package} command (@pxref{Invoking guix package}). Thus, it is mainly useful for distribution developers." -msgstr "" +msgstr "La commande @command{guix build} construit des paquets ou des dérivations et leurs dépendances et affiche les chemins du dépôt qui en résulte. Remarquez qu'elle ne modifie pas le profil de l'utilisateur — c'est le travail de la commande @command{guix package} (@pxref{Invoking guix package}). Ainsi, elle est surtout utile pour les développeurs de la distribution." #. type: Plain text #: doc/guix.texi:5571 doc/guix.texi:6235 doc/guix.texi:6302 doc/guix.texi:6995 @@ -10450,23 +10629,23 @@ msgstr "La syntaxe générale est :" #: doc/guix.texi:5574 #, no-wrap msgid "guix build @var{options} @var{package-or-derivation}@dots{}\n" -msgstr "" +msgstr "guix build @var{options} @var{package-or-derivation}@dots{}\n" #. type: Plain text #: doc/guix.texi:5579 msgid "As an example, the following command builds the latest versions of Emacs and of Guile, displays their build logs, and finally displays the resulting directories:" -msgstr "" +msgstr "Par exemple, la commande suivante construit la dernière version d'Emacs et de Guile, affiche leur journaux de construction et enfin affiche les répertoires des résultats :" #. type: example #: doc/guix.texi:5582 #, no-wrap msgid "guix build emacs guile\n" -msgstr "" +msgstr "guix build emacs guile\n" #. type: Plain text #: doc/guix.texi:5585 msgid "Similarly, the following command builds all the available packages:" -msgstr "" +msgstr "De même, la commande suivante construit tous les paquets disponibles :" #. type: example #: doc/guix.texi:5589 @@ -10475,130 +10654,132 @@ msgid "" "guix build --quiet --keep-going \\\n" " `guix package -A | cut -f1,2 --output-delimiter=@@`\n" msgstr "" +"guix build --quiet --keep-going \\\n" +" `guix package -A | cut -f1,2 --output-delimiter=@@`\n" #. type: Plain text #: doc/guix.texi:5597 msgid "@var{package-or-derivation} may be either the name of a package found in the software distribution such as @code{coreutils} or @code{coreutils@@8.20}, or a derivation such as @file{/gnu/store/@dots{}-coreutils-8.19.drv}. In the former case, a package with the corresponding name (and optionally version) is searched for among the GNU distribution modules (@pxref{Package Modules})." -msgstr "" +msgstr "@var{package-or-derivation} peut être soit le nom d'un paquet trouvé dans la distribution logicielle comme @code{coreutils}, soit @code{coreutils@@8.20}, soit une dérivation comme @file{/gnu/store/@dots{}-coreutils-8.19.drv}. Dans le premier cas, la commande cherchera un paquet avec le nom correspondant (et éventuellement la version) dans les modules de la distribution GNU (@pxref{Package Modules})." #. type: Plain text #: doc/guix.texi:5602 msgid "Alternatively, the @code{--expression} option may be used to specify a Scheme expression that evaluates to a package; this is useful when disambiguating among several same-named packages or package variants is needed." -msgstr "" +msgstr "Autrement, l'option @code{--expression} peut être utilisée pour spécifier une expression Scheme qui s'évalue en un paquet ; c'est utile pour différencier des paquets avec le même nom ou des variantes de paquets." #. type: Plain text #: doc/guix.texi:5605 msgid "There may be zero or more @var{options}. The available options are described in the subsections below." -msgstr "" +msgstr "Il peut y avoir aucune, une ou plusieurs @var{options}. Les options disponibles sont décrites dans les sous-sections ci-dessous." #. type: Plain text #: doc/guix.texi:5620 msgid "A number of options that control the build process are common to @command{guix build} and other commands that can spawn builds, such as @command{guix package} or @command{guix archive}. These are the following:" -msgstr "" +msgstr "Un certain nombre d'options qui contrôlent le processus de construction sont communes avec @command{guix build} et les autres commandes qui peuvent générer des constructions, comme @command{guix package} ou @command{guix archive}. Voici ces options :" #. type: item #: doc/guix.texi:5623 #, no-wrap msgid "--load-path=@var{directory}" -msgstr "" +msgstr "--load-path=@var{répertoire}" #. type: itemx #: doc/guix.texi:5624 #, no-wrap msgid "-L @var{directory}" -msgstr "" +msgstr "-L @var{répertoire}" #. type: table #: doc/guix.texi:5627 msgid "Add @var{directory} to the front of the package module search path (@pxref{Package Modules})." -msgstr "" +msgstr "Ajoute @var{répertoire} au début du chemin de recherche de module de paquets (@pxref{Package Modules})." #. type: table #: doc/guix.texi:5630 msgid "This allows users to define their own packages and make them visible to the command-line tools." -msgstr "" +msgstr "Cela permet à des utilisateurs de définir leur propres paquets et les rendre disponibles aux outils en ligne de commande." #. type: item #: doc/guix.texi:5631 #, no-wrap msgid "--keep-failed" -msgstr "" +msgstr "--keep-failed" #. type: itemx #: doc/guix.texi:5632 #, no-wrap msgid "-K" -msgstr "" +msgstr "-K" #. type: table #: doc/guix.texi:5638 msgid "Keep the build tree of failed builds. Thus, if a build fails, its build tree is kept under @file{/tmp}, in a directory whose name is shown at the end of the build log. This is useful when debugging build issues. @xref{Debugging Build Failures}, for tips and tricks on how to debug build issues." -msgstr "" +msgstr "Garde l'arborescence de construction des constructions en échec. Ainsi, si une construction échoue, son arborescence de construction est préservée dans @file{/tmp}, dans un répertoire dont le nom est affiché à la fin du journal de construction. Cela est utile pour déboguer des échecs de construction. @xref{Debugging Build Failures}, pour des astuces sur la manière de déboguer des problèmes de construction." #. type: item #: doc/guix.texi:5639 #, no-wrap msgid "--keep-going" -msgstr "" +msgstr "--keep-going" #. type: itemx #: doc/guix.texi:5640 #, no-wrap msgid "-k" -msgstr "" +msgstr "-k" #. type: table #: doc/guix.texi:5643 msgid "Keep going when some of the derivations fail to build; return only once all the builds have either completed or failed." -msgstr "" +msgstr "Continue lorsque certaines dérivations échouent ; ne s'arrête que lorsque toutes les constructions ont soit réussies, soit échouées." #. type: table #: doc/guix.texi:5646 msgid "The default behavior is to stop as soon as one of the specified derivations has failed." -msgstr "" +msgstr "Le comportement par défaut est de s'arrêter dès qu'une des dérivations spécifiées échoue." #. type: item #: doc/guix.texi:5647 #, no-wrap msgid "--dry-run" -msgstr "" +msgstr "--dry-run" #. type: itemx #: doc/guix.texi:5648 #, no-wrap msgid "-n" -msgstr "" +msgstr "-n" #. type: table #: doc/guix.texi:5650 msgid "Do not build the derivations." -msgstr "" +msgstr "Ne pas construire les dérivations." #. type: anchor{#1} #: doc/guix.texi:5652 msgid "fallback-option" -msgstr "" +msgstr "option de repli" #. type: item #: doc/guix.texi:5652 #, no-wrap msgid "--fallback" -msgstr "" +msgstr "--fallback" #. type: table #: doc/guix.texi:5655 msgid "When substituting a pre-built binary fails, fall back to building packages locally (@pxref{Substitution Failure})." -msgstr "" +msgstr "Lorsque la substitution d'un binaire pré-compilé échoue, construit les paquets localement à la place (@pxref{Substitution Failure})." #. type: anchor{#1} #: doc/guix.texi:5661 msgid "client-substitute-urls" -msgstr "" +msgstr "client-substitute-urls" #. type: table #: doc/guix.texi:5661 msgid "Consider @var{urls} the whitespace-separated list of substitute source URLs, overriding the default list of URLs of @command{guix-daemon} (@pxref{daemon-substitute-urls,, @command{guix-daemon} URLs})." -msgstr "" +msgstr "Considère @var{urls} comme une liste d'URL de sources de substituts séparés par des espaces, et remplace la liste par défaut d'URL de @command{guix-daemon} (@pxref{daemon-substitute-urls,, @command{guix-daemon} URLs})." #. type: table #: doc/guix.texi:5665 @@ -10608,178 +10789,178 @@ msgstr "Cela signifie que les substituts peuvent être téléchargés depuis @va #. type: table #: doc/guix.texi:5668 msgid "When @var{urls} is the empty string, substitutes are effectively disabled." -msgstr "" +msgstr "Lorsque @var{urls} est la chaîne vide, cela a pour effet de désactiver la substitution." #. type: item #: doc/guix.texi:5674 #, no-wrap msgid "--no-grafts" -msgstr "" +msgstr "--no-grafts" #. type: table #: doc/guix.texi:5678 msgid "Do not ``graft'' packages. In practice, this means that package updates available as grafts are not applied. @xref{Security Updates}, for more information on grafts." -msgstr "" +msgstr "Ne par « greffer » les paquets. En pratique, cela signifie que les mises à jour des paquets disponibles comme des greffes ne sont pas appliquées. @xref{Security Updates}, pour plus d'information sur les greffes." #. type: item #: doc/guix.texi:5679 #, no-wrap msgid "--rounds=@var{n}" -msgstr "" +msgstr "--rounds=@var{n}" #. type: table #: doc/guix.texi:5682 msgid "Build each derivation @var{n} times in a row, and raise an error if consecutive build results are not bit-for-bit identical." -msgstr "" +msgstr "Construit chaque dérivation @var{n} fois d'affilé, et renvoie une erreur si les constructions consécutives ne sont pas identiques bit-à-bit." #. type: table #: doc/guix.texi:5687 msgid "This is a useful way to detect non-deterministic builds processes. Non-deterministic build processes are a problem because they make it practically impossible for users to @emph{verify} whether third-party binaries are genuine. @xref{Invoking guix challenge}, for more." -msgstr "" +msgstr "Cela est une manière utile pour détecter des processus de construction non déterministes. Les processus de construction non déterministes sont problématiques car ils rendent pratiquement impossible la @emph{vérification} par les utilisateurs de l'authenticité de binaires tiers. @xref{Invoking guix challenge}, pour plus d'informations." #. type: table #: doc/guix.texi:5693 msgid "Note that, currently, the differing build results are not kept around, so you will have to manually investigate in case of an error---e.g., by stashing one of the build results with @code{guix archive --export} (@pxref{Invoking guix archive}), then rebuilding, and finally comparing the two results." -msgstr "" +msgstr "Remarquez que, les résultats qui diffèrent ne sont pas gardés, donc vous devrez inspecter manuellement chaque erreur — p.@: ex.@: en gardant l'un des résultats avec @code{guix archive --export} (@pxref{Invoking guix archive}), puis en reconstruisant, et enfin en comparant les deux résultats." #. type: table #: doc/guix.texi:5698 msgid "Do not attempt to offload builds @i{via} the ``build hook'' of the daemon (@pxref{Daemon Offload Setup}). That is, always build things locally instead of offloading builds to remote machines." -msgstr "" +msgstr "N'essaye pas de décharger les constructions via le « crochet de construction » du démon (@pxref{Daemon Offload Setup}). C'est-à-dire que tout sera construit localement plutôt que de décharger les constructions à une machine distante." #. type: table #: doc/guix.texi:5705 msgid "By default, the daemon's setting is honored (@pxref{Invoking guix-daemon, @code{--max-silent-time}})." -msgstr "" +msgstr "Par défaut, les paramètres du démon sont pris en compte (@pxref{Invoking guix-daemon, @code{--max-silent-time}})." #. type: table #: doc/guix.texi:5712 msgid "By default, the daemon's setting is honored (@pxref{Invoking guix-daemon, @code{--timeout}})." -msgstr "" +msgstr "Par défaut, les paramètres du démon sont pris en compte (@pxref{Invoking guix-daemon, @code{--timeout}})." #. type: item #: doc/guix.texi:5713 #, no-wrap msgid "--verbosity=@var{level}" -msgstr "" +msgstr "--verbosity=@var{level}" #. type: table #: doc/guix.texi:5717 msgid "Use the given verbosity level. @var{level} must be an integer between 0 and 5; higher means more verbose output. Setting a level of 4 or more may be helpful when debugging setup issues with the build daemon." -msgstr "" +msgstr "Utilise le niveau de verbosité donné. @var{level} doit être un entier entre 0 et 5 ; les entiers les plus hauts signifient une sortie plus verbeuse. Le mettre à 4 ou plus peut être utile pour déboguer des problèmes de configuration du démon de construction." #. type: table #: doc/guix.texi:5722 msgid "Allow the use of up to @var{n} CPU cores for the build. The special value @code{0} means to use as many CPU cores as available." -msgstr "" +msgstr "Permet d'utiliser jusqu'à @var{n} cœurs du CPU pour la construction. La valeur spéciale @code{0} signifie autant de cœurs que possible." #. type: table #: doc/guix.texi:5728 msgid "Allow at most @var{n} build jobs in parallel. @xref{Invoking guix-daemon, @code{--max-jobs}}, for details about this option and the equivalent @command{guix-daemon} option." -msgstr "" +msgstr "Permet au plus @var{n} travaux de construction en parallèle. @xref{Invoking guix-daemon, @code{--max-jobs}}, pour plus de détails sur cette option et l'option équivalente pour @command{guix-daemon}." #. type: Plain text #: doc/guix.texi:5735 msgid "Behind the scenes, @command{guix build} is essentially an interface to the @code{package-derivation} procedure of the @code{(guix packages)} module, and to the @code{build-derivations} procedure of the @code{(guix derivations)} module." -msgstr "" +msgstr "Sous le capot, @command{guix build} est surtout un interface à la procédure @code{package-derivation} du module @code{(guix packages)}, et à la procédure @code{build-derivations} du module @code{(guix derivations)}." #. type: Plain text #: doc/guix.texi:5739 msgid "In addition to options explicitly passed on the command line, @command{guix build} and other @command{guix} commands that support building honor the @code{GUIX_BUILD_OPTIONS} environment variable." -msgstr "" +msgstr "En plus des options passées explicitement par la ligne de commande, @command{guix build} et les autres commande @command{guix} qui peuvent effectuer des construction honorent la variable d'environnement @code{GUIX_BUILD_OPTIONS}." #. type: defvr #: doc/guix.texi:5740 #, no-wrap msgid "{Environment Variable} GUIX_BUILD_OPTIONS" -msgstr "" +msgstr "{Variable d'environnement} GUIX_BUILD_OPTIONS" #. type: defvr #: doc/guix.texi:5745 msgid "Users can define this variable to a list of command line options that will automatically be used by @command{guix build} and other @command{guix} commands that can perform builds, as in the example below:" -msgstr "" +msgstr "Les utilisateurs peuvent définir cette variable à une liste d'options de la ligne de commande qui seront automatiquement utilisées par @command{guix build} et les autres commandes @command{guix} qui peuvent effectuer des constructions, comme dans l'exemple suivant :" #. type: example #: doc/guix.texi:5748 #, no-wrap msgid "$ export GUIX_BUILD_OPTIONS=\"--no-substitutes -c 2 -L /foo/bar\"\n" -msgstr "" +msgstr "$ export GUIX_BUILD_OPTIONS=\"--no-substitutes -c 2 -L /foo/bar\"\n" #. type: defvr #: doc/guix.texi:5752 msgid "These options are parsed independently, and the result is appended to the parsed command-line options." -msgstr "" +msgstr "Ces options sont analysées indépendamment, et le résultat est ajouté aux options de la ligne de commande analysées." #. type: cindex #: doc/guix.texi:5758 #, no-wrap msgid "package variants" -msgstr "" +msgstr "variantes de paquets" #. type: Plain text #: doc/guix.texi:5766 msgid "Another set of command-line options supported by @command{guix build} and also @command{guix package} are @dfn{package transformation options}. These are options that make it possible to define @dfn{package variants}---for instance, packages built from different source code. This is a convenient way to create customized packages on the fly without having to type in the definitions of package variants (@pxref{Defining Packages})." -msgstr "" +msgstr "Un autre ensemble d'options de la ligne de commande supportés par @command{guix build} et aussi @command{guix package} sont les @dfn{options de transformation de paquets}. Ce sont des options qui rendent possible la définition de @dfn{variantes de paquets} — par exemple, des paquets construit à partir de sources différentes. C'est une manière simple de créer des paquets personnalisés à la volée sans avoir à taper les définitions de variantes de paquets (@pxref{Defining Packages})." #. type: item #: doc/guix.texi:5769 #, no-wrap msgid "--with-source=@var{source}" -msgstr "" +msgstr "--with-source=@var{source}" #. type: itemx #: doc/guix.texi:5770 #, no-wrap msgid "--with-source=@var{package}=@var{source}" -msgstr "" +msgstr "--with-source=@var{paquet}=@var{source}" #. type: itemx #: doc/guix.texi:5771 #, no-wrap msgid "--with-source=@var{package}@@@var{version}=@var{source}" -msgstr "" +msgstr "--with-source=@var{paquet}@@@var{version}=@var{source}" #. type: table #: doc/guix.texi:5776 msgid "Use @var{source} as the source of @var{package}, and @var{version} as its version number. @var{source} must be a file name or a URL, as for @command{guix download} (@pxref{Invoking guix download})." -msgstr "" +msgstr "Utiles @var{source} comme la source de @var{paquet}, et @var{version} comme son numéro de version. @var{source} doit être un nom de fichier ou une URL, comme pour @command{guix download} (@pxref{Invoking guix download})." #. type: table #: doc/guix.texi:5782 msgid "When @var{package} is omitted, it is taken to be the package name specified on the command line that matches the base of @var{source}---e.g., if @var{source} is @code{/src/guile-2.0.10.tar.gz}, the corresponding package is @code{guile}." -msgstr "" +msgstr "Lorsque @var{paquet} est omis, la commande utilisera le nom de paquet spécifié par la base de @var{source} — p.@: ex.@: si @var{source} est @code{/src/guix-2.0.10.tar.gz}, le paquet correspondant est @code{guile}." #. type: table #: doc/guix.texi:5785 msgid "Likewise, when @var{version} is omitted, the version string is inferred from @var{source}; in the previous example, it is @code{2.0.10}." -msgstr "" +msgstr "De même, lorsque @var{version} est omis, la chaîne de version est inférée à partir de @var{source} ; dans l'exemple précédent, il s'agit de @code{2.0.10}." #. type: table #: doc/guix.texi:5790 msgid "This option allows users to try out versions of packages other than the one provided by the distribution. The example below downloads @file{ed-1.7.tar.gz} from a GNU mirror and uses that as the source for the @code{ed} package:" -msgstr "" +msgstr "Cette option permet aux utilisateurs d'essayer des version des paquets différentes de celles fournies par la distribution. L'exemple ci-dessous télécharge @file{ed-1.7.tar.g} depuis un mirroir GNU et l'utilise comme source pour le paquet @code{ed} :" #. type: example #: doc/guix.texi:5793 #, no-wrap msgid "guix build ed --with-source=mirror://gnu/ed/ed-1.7.tar.gz\n" -msgstr "" +msgstr "guix build ed --with-source=mirror://gnu/ed/ed-1.7.tar.gz\n" #. type: table #: doc/guix.texi:5797 msgid "As a developer, @code{--with-source} makes it easy to test release candidates:" -msgstr "" +msgstr "En tant que développeur, @code{--with-source} permet de tester facilement des version bêta :" #. type: example #: doc/guix.texi:5800 #, no-wrap msgid "guix build guile --with-source=../guile-2.0.9.219-e1bb7.tar.xz\n" -msgstr "" +msgstr "guix build guile --with-source=../guile-2.0.9.219-e1bb7.tar.xz\n" #. type: table #: doc/guix.texi:5803 msgid "@dots{} or to build from a checkout in a pristine environment:" -msgstr "" +msgstr "@dots{} ou pour construire un dépôt de gestion de version dans un environnement vierge :" #. type: example #: doc/guix.texi:5807 @@ -10788,183 +10969,185 @@ msgid "" "$ git clone git://git.sv.gnu.org/guix.git\n" "$ guix build guix --with-source=guix@@1.0=./guix\n" msgstr "" +"$ git clone git://git.sv.gnu.org/guix.git\n" +"$ guix build guix --with-source=guix@@1.0=./guix\n" #. type: item #: doc/guix.texi:5809 #, no-wrap msgid "--with-input=@var{package}=@var{replacement}" -msgstr "" +msgstr "--with-input=@var{paquet}=@var{remplaçant}" #. type: table #: doc/guix.texi:5814 msgid "Replace dependency on @var{package} by a dependency on @var{replacement}. @var{package} must be a package name, and @var{replacement} must be a package specification such as @code{guile} or @code{guile@@1.8}." -msgstr "" +msgstr "Remplace la dépendance sur @var{paquet} par une dépendance à @var{remplaçant}. @var{paquet} doit être un nom de paquet et @var{remplaçant} doit être une spécification de paquet comme @code{guile} ou @code{guile@@1.8}." #. type: table #: doc/guix.texi:5818 msgid "For instance, the following command builds Guix, but replaces its dependency on the current stable version of Guile with a dependency on the legacy version of Guile, @code{guile@@2.0}:" -msgstr "" +msgstr "Par exemple, la commande suivante construit Guix, mais remplace sa dépendance à la version stable actuelle de Guile par une dépendance à une ancienne version de Guile, @code{guile@@2.0} :" #. type: example #: doc/guix.texi:5821 #, no-wrap msgid "guix build --with-input=guile=guile@@2.0 guix\n" -msgstr "" +msgstr "guix build --with-input=guile=guile@@2.0 guix\n" #. type: table #: doc/guix.texi:5826 msgid "This is a recursive, deep replacement. So in this example, both @code{guix} and its dependency @code{guile-json} (which also depends on @code{guile}) get rebuilt against @code{guile@@2.0}." -msgstr "" +msgstr "C'est un remplacement récursif profond. Donc dans cet exemple, à la fois @code{guix} et ses dépendances @code{guile-json} (qui dépend aussi de @code{guile}) sont reconstruits avec @code{guile@@2.0}." #. type: table #: doc/guix.texi:5829 msgid "This is implemented using the @code{package-input-rewriting} Scheme procedure (@pxref{Defining Packages, @code{package-input-rewriting}})." -msgstr "" +msgstr "Cette option est implémentée avec la procédure Scheme @code{package-input-rewriting} (@pxref{Defining Packages, @code{package-input-rewriting}})." #. type: item #: doc/guix.texi:5830 #, no-wrap msgid "--with-graft=@var{package}=@var{replacement}" -msgstr "" +msgstr "--with-graft=@var{paquet}=@var{remplaçant}" #. type: table #: doc/guix.texi:5836 msgid "This is similar to @code{--with-input} but with an important difference: instead of rebuilding the whole dependency chain, @var{replacement} is built and then @dfn{grafted} onto the binaries that were initially referring to @var{package}. @xref{Security Updates}, for more information on grafts." -msgstr "" +msgstr "Cette option est similaire à @code{--with-input} mais avec une différence importante : plutôt que de reconstruire la chaîne de dépendance complète, @var{remplaçant} est construit puis @dfn{greffé} sur les binaires qui référençaient initialement @var{paquet}. @xref{Security Updates}, pour plus d'information sur les greffes." #. type: table #: doc/guix.texi:5840 msgid "For example, the command below grafts version 3.5.4 of GnuTLS onto Wget and all its dependencies, replacing references to the version of GnuTLS they currently refer to:" -msgstr "" +msgstr "Par exemple, la commande ci-dessous greffe la version 3.5.4 de GnuTLS sur Wget et toutes ses dépendances, en remplaçant les références à la version actuelle de GnuTLS à laquelle ils se réfèrent actuellement :" #. type: example #: doc/guix.texi:5843 #, no-wrap msgid "guix build --with-graft=gnutls=gnutls@@3.5.4 wget\n" -msgstr "" +msgstr "guix build --with-graft=gnutls=gnutls@@3.5.4 wget\n" #. type: table #: doc/guix.texi:5852 msgid "This has the advantage of being much faster than rebuilding everything. But there is a caveat: it works if and only if @var{package} and @var{replacement} are strictly compatible---for example, if they provide a library, the application binary interface (ABI) of those libraries must be compatible. If @var{replacement} is somehow incompatible with @var{package}, then the resulting package may be unusable. Use with care!" -msgstr "" +msgstr "Cela a l'avantage d'être bien plus rapide que de tout reconstruire. Mais il y a un piège : cela ne fonctionne que si @var{paquet} et @var{remplaçant} sont strictement compatibles — par exemple, s'ils fournissent une bibliothèque, l'interface binaire applicative (ABI) de ces bibliothèques doivent être compatibles. Si @var{remplaçant} est incompatible avec @var{paquet}, alors le paquet qui en résulte peut devenir inutilisable. À utilisez avec précaution !" #. type: Plain text #: doc/guix.texi:5860 msgid "The command-line options presented below are specific to @command{guix build}." -msgstr "" +msgstr "Les options de la ligne de commande ci-dessous sont spécifiques à @command{guix build}." #. type: item #: doc/guix.texi:5863 #, no-wrap msgid "--quiet" -msgstr "" +msgstr "--quiet" #. type: itemx #: doc/guix.texi:5864 #, no-wrap msgid "-q" -msgstr "" +msgstr "-q" #. type: table #: doc/guix.texi:5868 msgid "Build quietly, without displaying the build log. Upon completion, the build log is kept in @file{/var} (or similar) and can always be retrieved using the @option{--log-file} option." -msgstr "" +msgstr "Construire en silence, sans afficher les journaux de construction. À la fin, le journal de construction est gardé dans @file{/var} (ou similaire) et on peut toujours l'y trouver avec l'option @option{--log-file}." #. type: item #: doc/guix.texi:5869 #, no-wrap msgid "--file=@var{file}" -msgstr "" +msgstr "--file=@var{fichier}" #. type: table #: doc/guix.texi:5874 msgid "Build the package or derivation that the code within @var{file} evaluates to." -msgstr "" +msgstr "Construit le paquet ou la dérivation en lequel le code dans @var{file} s'évalue." #. type: table #: doc/guix.texi:5877 msgid "As an example, @var{file} might contain a package definition like this (@pxref{Defining Packages}):" -msgstr "" +msgstr "Par exemple, @var{file} peut contenir une définition de paquet comme ceci (@pxref{Defining Packages}) :" #. type: table #: doc/guix.texi:5885 msgid "Build the package or derivation @var{expr} evaluates to." -msgstr "" +msgstr "Construit le paquet ou la dérivation en lequel @var{expr} s'évalue." #. type: table #: doc/guix.texi:5889 msgid "For example, @var{expr} may be @code{(@@ (gnu packages guile) guile-1.8)}, which unambiguously designates this specific variant of version 1.8 of Guile." -msgstr "" +msgstr "Par exemple, @var{expr} peut être @code{(@@ (gnu packages guile) guile-1.8)}, qui désigne sans ambiguïté cette variante spécifique de la version 1.8 de Guile." #. type: table #: doc/guix.texi:5893 msgid "Alternatively, @var{expr} may be a G-expression, in which case it is used as a build program passed to @code{gexp->derivation} (@pxref{G-Expressions})." -msgstr "" +msgstr "Autrement, @var{exp} peut être une G-expression, auquel cas elle est utilisée comme un programme de construction passé à @code{gexp->derivation} (@pxref{G-Expressions})." #. type: table #: doc/guix.texi:5897 msgid "Lastly, @var{expr} may refer to a zero-argument monadic procedure (@pxref{The Store Monad}). The procedure must return a derivation as a monadic value, which is then passed through @code{run-with-store}." -msgstr "" +msgstr "Enfin, @var{expr} peut se référer à une procédure monadique à au moins un argument (@pxref{The Store Monad}). La procédure doit renvoyer une dérivation comme une valeur monadique, qui est ensuite lancée à travers @code{run-with-store}." #. type: item #: doc/guix.texi:5898 #, no-wrap msgid "--source" -msgstr "" +msgstr "--source" #. type: itemx #: doc/guix.texi:5899 #, no-wrap msgid "-S" -msgstr "" +msgstr "-S" #. type: table #: doc/guix.texi:5902 msgid "Build the source derivations of the packages, rather than the packages themselves." -msgstr "" +msgstr "Construit les dérivation source des paquets, plutôt que des paquets eux-même." #. type: table #: doc/guix.texi:5906 msgid "For instance, @code{guix build -S gcc} returns something like @file{/gnu/store/@dots{}-gcc-4.7.2.tar.bz2}, which is the GCC source tarball." -msgstr "" +msgstr "Par exemple, @code{guix build -S gcc} renvoie quelque chose comme @file{/gnu/store/@dots{}-gcc-4.7.2.tar.bz2}, qui est l'archive des sources de GCC." #. type: table #: doc/guix.texi:5910 msgid "The returned source tarball is the result of applying any patches and code snippets specified in the package @code{origin} (@pxref{Defining Packages})." -msgstr "" +msgstr "L'archive des sources renvoyée est le résultat de l'application des correctifs et des extraits de code éventuels spécifiés dans le champ @code{origin} du paquet (@pxref{Defining Packages})." #. type: item #: doc/guix.texi:5911 #, no-wrap msgid "--sources" -msgstr "" +msgstr "--sources" #. type: table #: doc/guix.texi:5918 msgid "Fetch and return the source of @var{package-or-derivation} and all their dependencies, recursively. This is a handy way to obtain a local copy of all the source code needed to build @var{packages}, allowing you to eventually build them even without network access. It is an extension of the @code{--source} option and can accept one of the following optional argument values:" -msgstr "" +msgstr "Récupère et renvoie la source de @var{package-or-derivation} et toute ses dépendances, récursivement. C'est pratique pour obtenir une copie locale de tous les codes sources requis pour construire @var{packages}, ce qui vous permet de les construire plus tard même sans accès réseau. C'est une extension de l'option @code{--source} et peut accepter l'un des arguments facultatifs suivants :" #. type: item #: doc/guix.texi:5920 doc/guix.texi:7184 #, no-wrap msgid "package" -msgstr "" +msgstr "package" #. type: table #: doc/guix.texi:5923 msgid "This value causes the @code{--sources} option to behave in the same way as the @code{--source} option." -msgstr "" +msgstr "Cette valeur fait que l'option @code{--sources} se comporte comme l'option @code{--source}." #. type: item #: doc/guix.texi:5924 doc/guix.texi:12103 #, no-wrap msgid "all" -msgstr "" +msgstr "all" #. type: table #: doc/guix.texi:5927 msgid "Build the source derivations of all packages, including any source that might be listed as @code{inputs}. This is the default value." -msgstr "" +msgstr "Construit les dérivations des sources de tous les paquets, dont les sources qui pourraient être listées dans @code{inputs}. C'est la valeur par défaut." #. type: example #: doc/guix.texi:5933 @@ -10975,17 +11158,21 @@ msgid "" " /gnu/store/@dots{}-tzdata2015b.tar.gz.drv\n" " /gnu/store/@dots{}-tzcode2015b.tar.gz.drv\n" msgstr "" +"$ guix build --sources tzdata\n" +"The following derivations will be built:\n" +" /gnu/store/@dots{}-tzdata2015b.tar.gz.drv\n" +" /gnu/store/@dots{}-tzcode2015b.tar.gz.drv\n" #. type: item #: doc/guix.texi:5935 #, no-wrap msgid "transitive" -msgstr "" +msgstr "transitive" #. type: table #: doc/guix.texi:5939 msgid "Build the source derivations of all packages, as well of all transitive inputs to the packages. This can be used e.g. to prefetch package source for later offline building." -msgstr "" +msgstr "Construit les dérivations des sources de tous les paquets, ainsi que toutes celles les entrées transitives des paquets. On peut utiliser cette option pour précharger les sources des paquets pour les construire plus tard hors ligne par exemple." #. type: example #: doc/guix.texi:5950 @@ -11001,36 +11188,45 @@ msgid "" " /gnu/store/@dots{}-bash-4.3.tar.xz.drv\n" "@dots{}\n" msgstr "" +"$ guix build --sources=transitive tzdata\n" +"The following derivations will be built:\n" +" /gnu/store/@dots{}-tzcode2015b.tar.gz.drv\n" +" /gnu/store/@dots{}-findutils-4.4.2.tar.xz.drv\n" +" /gnu/store/@dots{}-grep-2.21.tar.xz.drv\n" +" /gnu/store/@dots{}-coreutils-8.23.tar.xz.drv\n" +" /gnu/store/@dots{}-make-4.1.tar.xz.drv\n" +" /gnu/store/@dots{}-bash-4.3.tar.xz.drv\n" +"@dots{}\n" #. type: quotation #: doc/guix.texi:5963 msgid "The @code{--system} flag is for @emph{native} compilation and must not be confused with cross-compilation. See @code{--target} below for information on cross-compilation." -msgstr "" +msgstr "Le drapeau @code{--system} est utilisé pour une compilation @emph{native} et ne doit pas être confondu avec une compilation croisée. Voir @code{--target} ci-dessous pour des informations sur la compilation croisée." #. type: table #: doc/guix.texi:5970 msgid "An example use of this is on Linux-based systems, which can emulate different personalities. For instance, passing @code{--system=i686-linux} on an @code{x86_64-linux} system or @code{--system=armhf-linux} on an @code{aarch64-linux} system allows you to build packages in a complete 32-bit environment." -msgstr "" +msgstr "Par exemple, passer @code{--system=i686-linux} sur un système @code{x86_64-linux} ou @code{--system=armhf-linux} sur un système @code{aarch64-linux} vous permet de construire des paquets dans un environnement entièrement 32-bits. C'est une exemple d'utilisation de cette option sur les systèmes Linux, qui peuvent émuler plusieurs personnalités." #. type: quotation #: doc/guix.texi:5975 msgid "Building for an @code{armhf-linux} system is unconditionally enabled on @code{aarch64-linux} machines, although certain aarch64 chipsets do not allow for this functionality, notably the ThunderX." -msgstr "" +msgstr "La possibilité de construire pour un système @code{armhf-linux} est activé sans condition sur les machines @code{aarch64-linux}, bien que certaines puces aarch64 n'en soient pas capables, comme les ThunderX." #. type: table #: doc/guix.texi:5981 msgid "Similarly, when transparent emulation with QEMU and @code{binfmt_misc} is enabled (@pxref{Virtualization Services, @code{qemu-binfmt-service-type}}), you can build for any system for which a QEMU @code{binfmt_misc} handler is installed." -msgstr "" +msgstr "De même, lorsque l'émulation transparente avec QEMU et @code{binfnmt_misc} est activée (@pxref{Virtualization Services, @code{qemu-binfmt-service-type}}), vous pouvez construire pour n'importe quel système pour lequel un gestionnaire QEMU @code{binfmt_misc} est installé." #. type: table #: doc/guix.texi:5985 msgid "Builds for a system other than that of the machine you are using can also be offloaded to a remote machine of the right architecture. @xref{Daemon Offload Setup}, for more information on offloading." -msgstr "" +msgstr "Les constructions pour un autre système que celui de la machine que vous utilisez peuvent aussi être déchargées à une machine distante de la bonne architecture. @xref{Daemon Offload Setup}, pour plus d'information sur le déchargement." #. type: anchor{#1} #: doc/guix.texi:5993 msgid "build-check" -msgstr "" +msgstr "vérification de la construction" #. type: item #: doc/guix.texi:5993 @@ -11053,7 +11249,7 @@ msgstr "reproductibilité, vérification" #. type: table #: doc/guix.texi:5999 msgid "Rebuild @var{package-or-derivation}, which are already available in the store, and raise an error if the build results are not bit-for-bit identical." -msgstr "" +msgstr "Reconstruit les @var{package-or-derivation}, qui sont déjà disponibles dans le dépôt et lève une erreur si les résultats des constructions ne sont pas identiques bit-à-bit." #. type: table #: doc/guix.texi:6004 @@ -11070,84 +11266,84 @@ msgstr "--repair" #: doc/guix.texi:6010 #, no-wrap msgid "repairing store items" -msgstr "" +msgstr "réparer les éléments du dépôt" #. type: table #: doc/guix.texi:6014 msgid "Attempt to repair the specified store items, if they are corrupt, by re-downloading or rebuilding them." -msgstr "" +msgstr "Essaye de réparer les éléments du dépôt spécifiés, s'ils sont corrompus, en les téléchargeant ou en les construisant à nouveau." #. type: table #: doc/guix.texi:6016 msgid "This operation is not atomic and thus restricted to @code{root}." -msgstr "" +msgstr "Cette opération n'est pas atomique et donc restreinte à l'utilisateur @code{root}" #. type: item #: doc/guix.texi:6017 #, no-wrap msgid "--derivations" -msgstr "" +msgstr "--derivations" #. type: table #: doc/guix.texi:6021 msgid "Return the derivation paths, not the output paths, of the given packages." -msgstr "" +msgstr "Renvoie les chemins de dérivation, et non les chemins de sortie, des paquets donnés." #. type: item #: doc/guix.texi:6022 doc/guix.texi:7441 doc/guix.texi:21109 #, no-wrap msgid "--root=@var{file}" -msgstr "" +msgstr "--root=@var{fichier}" #. type: itemx #: doc/guix.texi:6023 doc/guix.texi:7442 doc/guix.texi:21110 #, no-wrap msgid "-r @var{file}" -msgstr "" +msgstr "-r @var{fichier}" #. type: cindex #: doc/guix.texi:6024 #, no-wrap msgid "GC roots, adding" -msgstr "" +msgstr "racines du GC, ajout" #. type: cindex #: doc/guix.texi:6025 #, no-wrap msgid "garbage collector roots, adding" -msgstr "" +msgstr "ajout de racines au ramasse-miettes" #. type: table #: doc/guix.texi:6028 doc/guix.texi:21113 msgid "Make @var{file} a symlink to the result, and register it as a garbage collector root." -msgstr "" +msgstr "Fait de @var{fichier} un lien symbolique vers le résultat, et l'enregistre en tant que racine du ramasse-miettes." #. type: table #: doc/guix.texi:6034 msgid "Consequently, the results of this @command{guix build} invocation are protected from garbage collection until @var{file} is removed. When that option is omitted, build results are eligible for garbage collection as soon as the build completes. @xref{Invoking guix gc}, for more on GC roots." -msgstr "" +msgstr "En conséquence, les résultats de cette invocation de @command{guix build} sont protégés du ramasse-miettes jusqu'à ce que @var{fichier} soit supprimé. Lorsque cette option est omise, les constructions sont susceptibles d'être glanées." #. type: item #: doc/guix.texi:6035 #, no-wrap msgid "--log-file" -msgstr "" +msgstr "--log-file" #. type: cindex #: doc/guix.texi:6036 #, no-wrap msgid "build logs, access" -msgstr "" +msgstr "journaux de construction, accès" #. type: table #: doc/guix.texi:6040 msgid "Return the build log file names or URLs for the given @var{package-or-derivation}, or raise an error if build logs are missing." -msgstr "" +msgstr "Renvoie les noms des journaux de construction ou les URL des @var{package-or-derivation} donnés ou lève une erreur si les journaux de construction sont absents." #. type: table #: doc/guix.texi:6043 msgid "This works regardless of how packages or derivations are specified. For instance, the following invocations are equivalent:" -msgstr "" +msgstr "Cela fonctionne indépendamment de la manière dont les paquets ou les dérivations sont spécifiées. Par exemple, les invocations suivantes sont équivalentes :" #. type: example #: doc/guix.texi:6049 @@ -11158,16 +11354,20 @@ msgid "" "guix build --log-file guile\n" "guix build --log-file -e '(@@ (gnu packages guile) guile-2.0)'\n" msgstr "" +"guix build --log-file `guix build -d guile`\n" +"guix build --log-file `guix build guile`\n" +"guix build --log-file guile\n" +"guix build --log-file -e '(@@ (gnu packages guile) guile-2.0)'\n" #. type: table #: doc/guix.texi:6054 msgid "If a log is unavailable locally, and unless @code{--no-substitutes} is passed, the command looks for a corresponding log on one of the substitute servers (as specified with @code{--substitute-urls}.)" -msgstr "" +msgstr "Si un journal n'est pas disponible localement, à moins que @code{--no-substitutes} ne soit passé, la commande cherche un journal correspondant sur l'un des serveurs de substituts (tels que spécifiés avec @code{--substitute-urls}.)" #. type: table #: doc/guix.texi:6057 msgid "So for instance, imagine you want to see the build log of GDB on MIPS, but you are actually on an @code{x86_64} machine:" -msgstr "" +msgstr "Donc par exemple, imaginons que vous souhaitiez voir le journal de construction de GDB sur MIPS, mais que vous n'avez qu'une machine @code{x86_64} :" #. type: example #: doc/guix.texi:6061 @@ -11176,32 +11376,34 @@ msgid "" "$ guix build --log-file gdb -s mips64el-linux\n" "https://hydra.gnu.org/log/@dots{}-gdb-7.10\n" msgstr "" +"$ guix build --log-file gdb -s mips64el-linux\n" +"https://hydra.gnu.org/log/@dots{}-gdb-7.10\n" #. type: table #: doc/guix.texi:6064 msgid "You can freely access a huge library of build logs!" -msgstr "" +msgstr "Vous pouvez accéder librement à un vaste bibliothèque de journaux de construction !" #. type: cindex #: doc/guix.texi:6069 #, no-wrap msgid "build failures, debugging" -msgstr "" +msgstr "échecs de construction, débogage" #. type: Plain text #: doc/guix.texi:6075 msgid "When defining a new package (@pxref{Defining Packages}), you will probably find yourself spending some time debugging and tweaking the build until it succeeds. To do that, you need to operate the build commands yourself in an environment as close as possible to the one the build daemon uses." -msgstr "" +msgstr "Lors de la définition d'un nouveau paquet (@pxref{Defining Packages}), vous passerez probablement du temps à déboguer et modifier la construction jusqu'à ce que ça marche. Pour cela, vous devez effectuer les commandes de construction vous-même dans un environnement le plus proche possible de celui qu'utilise le démon de construction." #. type: Plain text #: doc/guix.texi:6080 msgid "To that end, the first thing to do is to use the @option{--keep-failed} or @option{-K} option of @command{guix build}, which will keep the failed build tree in @file{/tmp} or whatever directory you specified as @code{TMPDIR} (@pxref{Invoking guix build, @code{--keep-failed}})." -msgstr "" +msgstr "Pour cela, la première chose à faire est d'utiliser l'option @option{--keep-failed} ou @option{-K} de @command{guix build}, qui gardera l'arborescence de construction dans @file{/tmp} ou le répertoire spécifié par @code{TMPDIR} (@pxref{Invoking guix build, @code{--keep-failed}})." #. type: Plain text #: doc/guix.texi:6086 msgid "From there on, you can @command{cd} to the failed build tree and source the @file{environment-variables} file, which contains all the environment variable definitions that were in place when the build failed. So let's say you're debugging a build failure in package @code{foo}; a typical session would look like this:" -msgstr "" +msgstr "À partir de là, vous pouvez vous déplacer dans l'arborescence de construction et sourcer le fichier @file{environment-variables}, qui contient toutes les variables d'environnement qui étaient définies lorsque la construction a échoué. Disons que vous déboguez un échec de construction dans le paquet @code{foo} ; une session typique ressemblerait à cela :" #. type: example #: doc/guix.texi:6093 @@ -11213,21 +11415,26 @@ msgid "" "$ source ./environment-variables\n" "$ cd foo-1.2\n" msgstr "" +"$ guix build foo -K\n" +"@dots{} @i{build fails}\n" +"$ cd /tmp/guix-build-foo.drv-0\n" +"$ source ./environment-variables\n" +"$ cd foo-1.2\n" #. type: Plain text #: doc/guix.texi:6097 msgid "Now, you can invoke commands as if you were the daemon (almost) and troubleshoot your build process." -msgstr "" +msgstr "Maintenant, vous pouvez invoquer les commandes comme si vous étiez le démon (presque) et corriger le processus de construction." #. type: Plain text #: doc/guix.texi:6103 msgid "Sometimes it happens that, for example, a package's tests pass when you run them manually but they fail when the daemon runs them. This can happen because the daemon runs builds in containers where, unlike in our environment above, network access is missing, @file{/bin/sh} does not exist, etc. (@pxref{Build Environment Setup})." -msgstr "" +msgstr "Parfois il arrive que, par exemple, les tests d'un paquet réussissent lorsque vous les lancez manuellement mais échouent quand ils sont lancés par le démon. Cela peut arriver parce que le démon tourne dans un conteneur où, contrairement à notre environnement au-dessus, l'accès réseau est indisponible, @file{/bin/sh} n'existe pas, etc (@pxref{Build Environment Setup})." #. type: Plain text #: doc/guix.texi:6106 msgid "In such cases, you may need to run inspect the build process from within a container similar to the one the build daemon creates:" -msgstr "" +msgstr "Dans ce cas, vous pourriez avoir besoin de lancer le processus de construction dans un conteneur similaire à celui que le démon crée :" #. type: example #: doc/guix.texi:6114 @@ -11240,250 +11447,256 @@ msgid "" "[env]# source ./environment-variables\n" "[env]# cd foo-1.2\n" msgstr "" +"$ guix build -K foo\n" +"@dots{}\n" +"$ cd /tmp/guix-build-foo.drv-0\n" +"$ guix environment --no-grafts -C foo --ad-hoc strace gdb\n" +"[env]# source ./environment-variables\n" +"[env]# cd foo-1.2\n" #. type: Plain text #: doc/guix.texi:6123 msgid "Here, @command{guix environment -C} creates a container and spawns a new shell in it (@pxref{Invoking guix environment}). The @command{--ad-hoc strace gdb} part adds the @command{strace} and @command{gdb} commands to the container, which would may find handy while debugging. The @option{--no-grafts} option makes sure we get the exact same environment, with ungrafted packages (@pxref{Security Updates}, for more info on grafts)." -msgstr "" +msgstr "Ici, @command{guix environment -C} crée un conteneur et démarre un nouveau shell dedans (@pxref{Invoking guix environment}). La partie @command{--ad-hoc strace gdb} ajoute les commandes @command{strace} et @command{gdb} dans le conteneur, ce qui pourrait s'avérer utile pour le débogage. L'option @option{--no-grafts} s'assure qu'on obtient le même environnement, avec des paquets non greffés (@pxref{Security Updates}, pour plus d'informations sur les greffes)." #. type: Plain text #: doc/guix.texi:6126 msgid "To get closer to a container like that used by the build daemon, we can remove @file{/bin/sh}:" -msgstr "" +msgstr "Pour obtenir un conteneur plus proche de ce qui serait utilisé par le démon de construction, on peut enlever @file{/bin/sh} :" #. type: example #: doc/guix.texi:6129 #, no-wrap msgid "[env]# rm /bin/sh\n" -msgstr "" +msgstr "[env]# rm /bin/sh\n" #. type: Plain text #: doc/guix.texi:6133 msgid "(Don't worry, this is harmless: this is all happening in the throw-away container created by @command{guix environment}.)" -msgstr "" +msgstr "Ne vous inquiétez pas, c'est sans danger : tout cela se passe dans un conteneur jetable créé par @command{guix environment}." #. type: Plain text #: doc/guix.texi:6136 msgid "The @command{strace} command is probably not in the search path, but we can run:" -msgstr "" +msgstr "La commande @command{strace} n'est probablement pas dans le chemin de recherche, mais on peut lancer :" #. type: example #: doc/guix.texi:6139 #, no-wrap msgid "[env]# $GUIX_ENVIRONMENT/bin/strace -f -o log make check\n" -msgstr "" +msgstr "[env]# $GUIX_ENVIRONMENT/bin/strace -f -o log make check\n" #. type: Plain text #: doc/guix.texi:6144 msgid "In this way, not only you will have reproduced the environment variables the daemon uses, you will also be running the build process in a container similar to the one the daemon uses." -msgstr "" +msgstr "De cette manière, non seulement vous aurez reproduit les variables d'environnement utilisées par le démon, mais vous lancerez aussi le processus de construction dans un conteneur similaire à celui utilisé par le démon." #. type: section #: doc/guix.texi:6147 #, no-wrap msgid "Invoking @command{guix edit}" -msgstr "" +msgstr "Invoquer @command{guix edit}" #. type: command{#1} #: doc/guix.texi:6149 #, no-wrap msgid "guix edit" -msgstr "" +msgstr "guix edit" #. type: cindex #: doc/guix.texi:6150 #, no-wrap msgid "package definition, editing" -msgstr "" +msgstr "définition de paquets, modification" #. type: Plain text #: doc/guix.texi:6155 msgid "So many packages, so many source files! The @command{guix edit} command facilitates the life of users and packagers by pointing their editor at the source file containing the definition of the specified packages. For instance:" -msgstr "" +msgstr "Tant de paquets, tant de fichiers source ! La commande @command{guix edit} facilite la vie des utilisateurs et des packagers en plaçant leur éditeur sur le fichier source qui contient la définition des paquets spécifiés. Par exemple :" #. type: example #: doc/guix.texi:6158 #, no-wrap msgid "guix edit gcc@@4.9 vim\n" -msgstr "" +msgstr "guix edit gcc@@4.9 vim\n" #. type: Plain text #: doc/guix.texi:6164 msgid "launches the program specified in the @code{VISUAL} or in the @code{EDITOR} environment variable to view the recipe of GCC@tie{}4.9.3 and that of Vim." -msgstr "" +msgstr "lance le programme spécifié dans la variable d'environnement @code{VISUAL} ou @code{EDITOR} pour visionner la recette de GCC@tie{}4.9.3 et cele de Vim." #. type: Plain text #: doc/guix.texi:6170 msgid "If you are using a Guix Git checkout (@pxref{Building from Git}), or have created your own packages on @code{GUIX_PACKAGE_PATH} (@pxref{Defining Packages}), you will be able to edit the package recipes. Otherwise, you will be able to examine the read-only recipes for packages currently in the store." -msgstr "" +msgstr "Si vous utilisez une copie du dépôt Git de Guix (@pxref{Building from Git}), ou que vous avez créé vos propres paquets dans @code{GUIX_PACKAGE_PATH} (@pxref{Defining Packages}), vous pourrez modifier les recettes des paquets. Sinon, vous pourrez examiner les recettes en lecture-seule des paquets actuellement dans le dépôt." #. type: section #: doc/guix.texi:6173 #, no-wrap msgid "Invoking @command{guix download}" -msgstr "" +msgstr "Invoquer @command{guix download}" #. type: command{#1} #: doc/guix.texi:6175 #, no-wrap msgid "guix download" -msgstr "" +msgstr "guix download" #. type: cindex #: doc/guix.texi:6176 #, no-wrap msgid "downloading package sources" -msgstr "" +msgstr "télécharger les sources des paquets" #. type: Plain text #: doc/guix.texi:6183 msgid "When writing a package definition, developers typically need to download a source tarball, compute its SHA256 hash, and write that hash in the package definition (@pxref{Defining Packages}). The @command{guix download} tool helps with this task: it downloads a file from the given URI, adds it to the store, and prints both its file name in the store and its SHA256 hash." -msgstr "" +msgstr "En écrivant des définitions de paquets, les développeurs ont généralement besoin de télécharger une archive des sources, calculer son hash SHA256 et écrire ce hash dans la définition du paquet (@pxref{Defining Packages}). L'outil @command{guix download} aide à cette tâche : il télécharge un fichier à l'URL donné, l'ajoute au dépôt et affiche à la fois son nom dans le dépôt et son hash SHA56." #. type: Plain text #: doc/guix.texi:6190 msgid "The fact that the downloaded file is added to the store saves bandwidth: when the developer eventually tries to build the newly defined package with @command{guix build}, the source tarball will not have to be downloaded again because it is already in the store. It is also a convenient way to temporarily stash files, which may be deleted eventually (@pxref{Invoking guix gc})." -msgstr "" +msgstr "Le fait que le fichier téléchargé soit ajouté au dépôt préserve la bande passante : losque les développeurs finissent par construire le paquet nouvellement défini avec @command{guix build}, l'archive des sources n'aura pas besoin d'être téléchargée de nouveau puisqu'elle se trouvera déjà dans le dépôt. C'est aussi une manière pratique de garder des fichiers temporairement, qui pourront ensuite être supprimés (@pxref{Invoking guix gc})." #. type: Plain text #: doc/guix.texi:6198 msgid "The @command{guix download} command supports the same URIs as used in package definitions. In particular, it supports @code{mirror://} URIs. @code{https} URIs (HTTP over TLS) are supported @emph{provided} the Guile bindings for GnuTLS are available in the user's environment; when they are not available, an error is raised. @xref{Guile Preparations, how to install the GnuTLS bindings for Guile,, gnutls-guile, GnuTLS-Guile}, for more information." -msgstr "" +msgstr "La commande @command{guix download} supporte les mêmes URI que celles utilisées dans les définitions de paquets. En particulier, elle supporte les URI @code {mirror://}. Les URI @code{http} (HTTP sur TLS) sont supportées @emph{si} les liaisons Guile de GnuTLS sont disponibles dans l'environnement de l'utilisateur ; si elle ne sont pas disponibles, une erreur est renvoyée. @xref{Guile Preparations, how to install the GnuTLS bindings for Guile,, gnutls-guile, GnuTLS-Guile}, pour plus d'informations." #. type: Plain text #: doc/guix.texi:6203 msgid "@command{guix download} verifies HTTPS server certificates by loading the certificates of X.509 authorities from the directory pointed to by the @code{SSL_CERT_DIR} environment variable (@pxref{X.509 Certificates}), unless @option{--no-check-certificate} is used." -msgstr "" +msgstr "@command{guix download} vérifie les certificats du serveur HTTPS en chargeant les autorités de certification X.509 depuis le répertoire vers lequel pointe la variable d'environnement @code{SSL_CERT_DIR} (@pxref{X.509 Certificates}), à moins que @option{--no-check-certificate} ne soit utilisé." #. type: Plain text #: doc/guix.texi:6205 doc/guix.texi:7721 msgid "The following options are available:" -msgstr "" +msgstr "Les options suivantes sont disponibles :" #. type: item #: doc/guix.texi:6207 doc/guix.texi:6246 #, no-wrap msgid "--format=@var{fmt}" -msgstr "" +msgstr "--format=@var{fmt}" #. type: itemx #: doc/guix.texi:6208 doc/guix.texi:6247 #, no-wrap msgid "-f @var{fmt}" -msgstr "" +msgstr "-f @var{fmt}" #. type: table #: doc/guix.texi:6211 msgid "Write the hash in the format specified by @var{fmt}. For more information on the valid values for @var{fmt}, @pxref{Invoking guix hash}." -msgstr "" +msgstr "Écrit le hash dans le format spécifié par @var{fmt}. Pour plus d'informations sur les valeurs valides pour @var{fmt}, @pxref{Invoking guix hash}." #. type: item #: doc/guix.texi:6212 #, no-wrap msgid "--no-check-certificate" -msgstr "" +msgstr "--no-check-certificate" #. type: table #: doc/guix.texi:6214 msgid "Do not validate the X.509 certificates of HTTPS servers." -msgstr "" +msgstr "Ne pas valider les certificats HTTPS des serveurs." #. type: table #: doc/guix.texi:6218 msgid "When using this option, you have @emph{absolutely no guarantee} that you are communicating with the authentic server responsible for the given URL, which makes you vulnerable to ``man-in-the-middle'' attacks." -msgstr "" +msgstr "Lorsque vous utilisez cette option, vous n'avez @emph{absolument aucune garanti} que vous communiquez avec le serveur authentique responsable de l'URL donnée, ce qui vous rend vulnérable à des attaques de « l'homme du milieu »." #. type: item #: doc/guix.texi:6219 #, no-wrap msgid "--output=@var{file}" -msgstr "" +msgstr "--output=@var{fichier}" #. type: itemx #: doc/guix.texi:6220 #, no-wrap msgid "-o @var{file}" -msgstr "" +msgstr "-o @var{fichier}" #. type: table #: doc/guix.texi:6223 msgid "Save the downloaded file to @var{file} instead of adding it to the store." -msgstr "" +msgstr "Enregistre le fichier téléchargé dans @var{fichier} plutôt que de l'ajouter au dépôt." #. type: section #: doc/guix.texi:6226 #, no-wrap msgid "Invoking @command{guix hash}" -msgstr "" +msgstr "Invoquer @command{guix hash}" #. type: command{#1} #: doc/guix.texi:6228 #, no-wrap msgid "guix hash" -msgstr "" +msgstr "guix hash" #. type: Plain text #: doc/guix.texi:6233 msgid "The @command{guix hash} command computes the SHA256 hash of a file. It is primarily a convenience tool for anyone contributing to the distribution: it computes the cryptographic hash of a file, which can be used in the definition of a package (@pxref{Defining Packages})." -msgstr "" +msgstr "La commande @command{guix hash} calcul le hash SHA256 d'un fichier. C'est surtout un outil pour simplifier la vie des contributeurs de la distribution : il calcul le hash cryptographique d'un fichier, qui peut être utilisé dans la définition d'un paquet (@pxref{Defining Packages})." #. type: example #: doc/guix.texi:6238 #, no-wrap msgid "guix hash @var{option} @var{file}\n" -msgstr "" +msgstr "guix hash @var{option} @var{fichier}\n" #. type: Plain text #: doc/guix.texi:6243 msgid "When @var{file} is @code{-} (a hyphen), @command{guix hash} computes the hash of data read from standard input. @command{guix hash} has the following options:" -msgstr "" +msgstr "Lorsque @var{fichier} est @code{-} (un tiret), @command{guix hash} calcul le hash des données lues depuis l'entrée standard. @command{guix hash} a les options suivantes :" #. type: table #: doc/guix.texi:6249 msgid "Write the hash in the format specified by @var{fmt}." -msgstr "" +msgstr "Écrit le hash dans le format spécifié par @var{fmt}." #. type: table #: doc/guix.texi:6252 msgid "Supported formats: @code{nix-base32}, @code{base32}, @code{base16} (@code{hex} and @code{hexadecimal} can be used as well)." -msgstr "" +msgstr "Les formats supportés sont : @code{nix-base32}, @code{base32}, @code{base16} (@code{hex} et @code{hexadecimal} peuvent aussi être utilisés)." #. type: table #: doc/guix.texi:6256 msgid "If the @option{--format} option is not specified, @command{guix hash} will output the hash in @code{nix-base32}. This representation is used in the definitions of packages." -msgstr "" +msgstr "Si l'option @option {--format} n'est pas spécifiée, @command{guix hash} affichera le hash en @code{nix-base32}. Cette représentation est utilisée dans les définitions des paquets." #. type: table #: doc/guix.texi:6260 msgid "Compute the hash on @var{file} recursively." -msgstr "" +msgstr "Calcule le hash sur @var{fichier} récursivement." #. type: table #: doc/guix.texi:6269 msgid "In this case, the hash is computed on an archive containing @var{file}, including its children if it is a directory. Some of the metadata of @var{file} is part of the archive; for instance, when @var{file} is a regular file, the hash is different depending on whether @var{file} is executable or not. Metadata such as time stamps has no impact on the hash (@pxref{Invoking guix archive})." -msgstr "" +msgstr "Dans ce cas, le hash est calculé sur une archive contenant @var{fichier}, dont ses enfants si c'est un répertoire. Certaines métadonnées de @var{fichier} fait partie de l'archive ; par exemple lorsque @var{fichier} est un fichier normal, le hash est différent que le @var{fichier} soit exécutable ou non. Les métadonnées comme un horodatage n'ont aucun impact sur le hash (@pxref{Invoking guix archive})." #. type: item #: doc/guix.texi:6270 #, no-wrap msgid "--exclude-vcs" -msgstr "" +msgstr "--exclude-vcs" #. type: itemx #: doc/guix.texi:6271 #, no-wrap msgid "-x" -msgstr "" +msgstr "-x" #. type: table #: doc/guix.texi:6274 msgid "When combined with @option{--recursive}, exclude version control system directories (@file{.bzr}, @file{.git}, @file{.hg}, etc.)" -msgstr "" +msgstr "Lorsqu'elle est combinée à @option{--recursive}, exclut les répertoires de système de contrôle de version (@file{.bzr}, @file{.git}, @file{.hg}, etc)." #. type: table #: doc/guix.texi:6279 msgid "As an example, here is how you would compute the hash of a Git checkout, which is useful when using the @code{git-fetch} method (@pxref{origin Reference}):" -msgstr "" +msgstr "Par exemple, voici comment calculer le hash d'un dépôt Git, ce qui est utile avec la méthode @code{git-fetch} (@pxref{origin Reference}) :" #. type: example #: doc/guix.texi:6284 @@ -11493,298 +11706,301 @@ msgid "" "$ cd foo\n" "$ guix hash -rx .\n" msgstr "" +"$ git clone http://example.org/foo.git\n" +"$ cd foo\n" +"$ guix hash -rx .\n" #. type: cindex #: doc/guix.texi:6288 doc/guix.texi:6293 #, no-wrap msgid "Invoking @command{guix import}" -msgstr "" +msgstr "Invoquer @command{guix import}" #. type: cindex #: doc/guix.texi:6290 #, no-wrap msgid "importing packages" -msgstr "" +msgstr "importer des paquets" #. type: cindex #: doc/guix.texi:6291 #, no-wrap msgid "package import" -msgstr "" +msgstr "paquets importés" #. type: cindex #: doc/guix.texi:6292 #, no-wrap msgid "package conversion" -msgstr "" +msgstr "conversion de paquets" #. type: Plain text #: doc/guix.texi:6300 msgid "The @command{guix import} command is useful for people who would like to add a package to the distribution with as little work as possible---a legitimate demand. The command knows of a few repositories from which it can ``import'' package metadata. The result is a package definition, or a template thereof, in the format we know (@pxref{Defining Packages})." -msgstr "" +msgstr "La commande @command{guix import} est utile pour les gens qui voudraient ajouter un paquet à la distribution avec aussi peu de travail que possible — une demande légitime. La commande connaît quelques dépôts logiciels d'où elle peut « importer » des métadonnées de paquets. Le résultat est une définition de paquet, ou un modèle de définition, dans le format reconnu par Guix (@pxref{Defining Packages})." #. type: example #: doc/guix.texi:6305 #, no-wrap msgid "guix import @var{importer} @var{options}@dots{}\n" -msgstr "" +msgstr "guix import @var{importer} @var{options}@dots{}\n" #. type: Plain text #: doc/guix.texi:6311 msgid "@var{importer} specifies the source from which to import package metadata, and @var{options} specifies a package identifier and other options specific to @var{importer}. Currently, the available ``importers'' are:" -msgstr "" +msgstr "@var{importer} spécifie la source depuis laquelle importer des métadonnées de paquets, et @var{options} spécifie un identifiant de paquet et d'autres options spécifiques à @var{importer}. Actuellement les « importateurs » disponibles sont :" #. type: item #: doc/guix.texi:6313 doc/guix.texi:6772 #, no-wrap msgid "gnu" -msgstr "" +msgstr "gnu" #. type: table #: doc/guix.texi:6317 msgid "Import metadata for the given GNU package. This provides a template for the latest version of that GNU package, including the hash of its source tarball, and its canonical synopsis and description." -msgstr "" +msgstr "Importe des métadonnées d'un paquet GNU donné. Cela fournit un modèle pour la dernière version de ce paquet GNU, avec le hash de son archive, le synopsis et la description canonique." #. type: table #: doc/guix.texi:6320 msgid "Additional information such as the package dependencies and its license needs to be figured out manually." -msgstr "" +msgstr "Les informations supplémentaires comme les dépendances du paquet et sa licence doivent être renseignées manuellement." #. type: table #: doc/guix.texi:6323 msgid "For example, the following command returns a package definition for GNU@tie{}Hello:" -msgstr "" +msgstr "Par exemple, la commande suivante renvoie une définition de paquets pour GNU@tie{}Hello :" #. type: example #: doc/guix.texi:6326 #, no-wrap msgid "guix import gnu hello\n" -msgstr "" +msgstr "guix import gnu hello\n" #. type: table #: doc/guix.texi:6329 doc/guix.texi:6547 doc/guix.texi:6592 doc/guix.texi:6616 msgid "Specific command-line options are:" -msgstr "" +msgstr "Les options spécifiques sont :" #. type: item #: doc/guix.texi:6331 doc/guix.texi:6873 #, no-wrap msgid "--key-download=@var{policy}" -msgstr "" +msgstr "--key-download=@var{politique}" #. type: table #: doc/guix.texi:6335 msgid "As for @code{guix refresh}, specify the policy to handle missing OpenPGP keys when verifying the package signature. @xref{Invoking guix refresh, @code{--key-download}}." -msgstr "" +msgstr "Comme pour @code{guix refresh}, spécifie la politique de gestion des clefs OpenPGP manquantes lors de la vérification de la signature d'un paquet. @xref{Invoking guix refresh, @code{--key-download}}." #. type: item #: doc/guix.texi:6337 doc/guix.texi:6338 doc/guix.texi:6790 #, no-wrap msgid "pypi" -msgstr "" +msgstr "pypi" #. type: table #: doc/guix.texi:6346 msgid "Import metadata from the @uref{https://pypi.python.org/, Python Package Index}@footnote{This functionality requires Guile-JSON to be installed. @xref{Requirements}.}. Information is taken from the JSON-formatted description available at @code{pypi.python.org} and usually includes all the relevant information, including package dependencies. For maximum efficiency, it is recommended to install the @command{unzip} utility, so that the importer can unzip Python wheels and gather data from them." -msgstr "" +msgstr "Importe des métadonnées depuis @uref{https://pypi.python.org/, l'index des paquets Python}@footnote{Cette fonctionnalité requiert l'installation de Guile-JSON. @xref{Requirements}.}. Les informations sont récupérées à partir de la description en JSON disponible sur @code{pypi.python.org} et inclus généralement toutes les informations utiles, dont les dépendances des paquets. Pour une efficacité maximale, il est recommandé d'installer l'utilitaire @command{unzip}, pour que l'importateur puisse dézipper les wheels Python et récupérer les informations contenues à l'intérieur." #. type: table #: doc/guix.texi:6349 msgid "The command below imports metadata for the @code{itsdangerous} Python package:" -msgstr "" +msgstr "La commande ci-dessous importe les métadonnées du paquet Python @code{itsdangerous} :" #. type: example #: doc/guix.texi:6352 #, no-wrap msgid "guix import pypi itsdangerous\n" -msgstr "" +msgstr "guix import pypi itsdangerous\n" #. type: item #: doc/guix.texi:6354 doc/guix.texi:6355 doc/guix.texi:6792 #, no-wrap msgid "gem" -msgstr "" +msgstr "gem" #. type: table #: doc/guix.texi:6366 msgid "Import metadata from @uref{https://rubygems.org/, RubyGems}@footnote{This functionality requires Guile-JSON to be installed. @xref{Requirements}.}. Information is taken from the JSON-formatted description available at @code{rubygems.org} and includes most relevant information, including runtime dependencies. There are some caveats, however. The metadata doesn't distinguish between synopses and descriptions, so the same string is used for both fields. Additionally, the details of non-Ruby dependencies required to build native extensions is unavailable and left as an exercise to the packager." -msgstr "" +msgstr "Importe des métadonnées de @uref{https://rubygems.org/, RubyGems}@footnote{Cette fonctionnalité requiert l'installation de Guile-JSON. @xref{Requirements}.}. Les informations sont récupérées au format JSON disponible sur @code{rubygems.org} et inclut les informations les plus utiles, comme les dépendances à l'exécution. Il y a des pièges cependant. Les métadonnées ne distinguent pas synopsis et description, donc la même chaîne est utilisée pour les deux champs. En plus, les détails des dépendances non Ruby requises pour construire des extensions natives sont indisponibles et laissé en exercice au packager." #. type: table #: doc/guix.texi:6368 msgid "The command below imports metadata for the @code{rails} Ruby package:" -msgstr "" +msgstr "La commande ci-dessous importe les métadonnées pour le paquet Ruby @code{rails} :" #. type: example #: doc/guix.texi:6371 #, no-wrap msgid "guix import gem rails\n" -msgstr "" +msgstr "guix import gem rails\n" #. type: item #: doc/guix.texi:6373 doc/guix.texi:6788 #, no-wrap msgid "cpan" -msgstr "" +msgstr "cpan" #. type: cindex #: doc/guix.texi:6374 #, no-wrap msgid "CPAN" -msgstr "" +msgstr "CPAN" #. type: table #: doc/guix.texi:6384 msgid "Import metadata from @uref{https://www.metacpan.org/, MetaCPAN}@footnote{This functionality requires Guile-JSON to be installed. @xref{Requirements}.}. Information is taken from the JSON-formatted metadata provided through @uref{https://fastapi.metacpan.org/, MetaCPAN's API} and includes most relevant information, such as module dependencies. License information should be checked closely. If Perl is available in the store, then the @code{corelist} utility will be used to filter core modules out of the list of dependencies." -msgstr "" +msgstr "Importe des métadonnées de @uref{https://www.metacpan.org/, MetaCPAN}@footnote{Cette fonctionnalité requiert l'installation de Guile-JSON. @xref{Requirements}.}. Les informations sont récupérées au format JSON disponible à travers @uref{https://fastapi.metacpan.org/, l'API de MetaCPAN} et inclus les informations les plus utiles, comme les dépendances des modules. L'information sur les licences doit être vérifiée avec attention. Si Perl est disponible dans le dépôt, alors l'utilitaire @code{corelist} sera utiliser pour exclure les modules du cœur de la distribution Perl de la liste des dépendances." #. type: table #: doc/guix.texi:6387 msgid "The command command below imports metadata for the @code{Acme::Boolean} Perl module:" -msgstr "" +msgstr "La commande ci-dessous importe les métadonnées du module Perl @code{Acme::Boolean} :" #. type: example #: doc/guix.texi:6390 #, no-wrap msgid "guix import cpan Acme::Boolean\n" -msgstr "" +msgstr "guix import cpan Acme::Boolean\n" #. type: item #: doc/guix.texi:6392 doc/guix.texi:6784 #, no-wrap msgid "cran" -msgstr "" +msgstr "cran" #. type: cindex #: doc/guix.texi:6393 #, no-wrap msgid "CRAN" -msgstr "" +msgstr "CRAN" #. type: cindex #: doc/guix.texi:6394 #, no-wrap msgid "Bioconductor" -msgstr "" +msgstr "Bioconductor" #. type: table #: doc/guix.texi:6398 msgid "Import metadata from @uref{https://cran.r-project.org/, CRAN}, the central repository for the @uref{http://r-project.org, GNU@tie{}R statistical and graphical environment}." -msgstr "" +msgstr "Importe des métadonnées de @uref{https://cran.r-project.org/, CRAN}, le dépôt central de @uref{http://r-project.org, l'environnement statistique et graphique GUN@tie{}R}." #. type: table #: doc/guix.texi:6400 msgid "Information is extracted from the @code{DESCRIPTION} file of the package." -msgstr "" +msgstr "Les informations sont extraites du fichier @file{DESCRIPTION} du paquet." #. type: table #: doc/guix.texi:6403 msgid "The command command below imports metadata for the @code{Cairo} R package:" -msgstr "" +msgstr "La commande ci-dessous importe les métadonnées du paquet R @code{Cairo} :" #. type: example #: doc/guix.texi:6406 #, no-wrap msgid "guix import cran Cairo\n" -msgstr "" +msgstr "guix import cran Cairo\n" #. type: table #: doc/guix.texi:6411 msgid "When @code{--recursive} is added, the importer will traverse the dependency graph of the given upstream package recursively and generate package expressions for all those packages that are not yet in Guix." -msgstr "" +msgstr "Lorsque l'option @code{--recursive} est utilisée, l'importateur traversera le graphe des dépendances du paquet amont récursivement et générera des expressions de paquets pour tous ceux qui ne sont pas déjà dans Guix." #. type: table #: doc/guix.texi:6416 msgid "When @code{--archive=bioconductor} is added, metadata is imported from @uref{https://www.bioconductor.org/, Bioconductor}, a repository of R packages for for the analysis and comprehension of high-throughput genomic data in bioinformatics." -msgstr "" +msgstr "Lorsque l'option @code{--archive=bioconductor} est utilisée, les métadonnées sont importées de @uref{https://www.bioconductor.org/, Bioconductor}, un répertoire de paquets R pour l'analyse et la compréhension de données génomiques volumineuses en bioinformatique." #. type: table #: doc/guix.texi:6419 msgid "Information is extracted from the @code{DESCRIPTION} file of a package published on the web interface of the Bioconductor SVN repository." -msgstr "" +msgstr "Les informations sont extraites du fichier @file{DESCRIPTION} d'un paquet publié sur l'interface web du dépôt SVN de Bioconductor." #. type: table #: doc/guix.texi:6422 msgid "The command below imports metadata for the @code{GenomicRanges} R package:" -msgstr "" +msgstr "La commande ci-dessous importe les métadonnées du paquet R @code{GenomicRanges} :" #. type: example #: doc/guix.texi:6425 #, no-wrap msgid "guix import cran --archive=bioconductor GenomicRanges\n" -msgstr "" +msgstr "guix import cran --archive=bioconductor GenomicRanges\n" #. type: item #: doc/guix.texi:6427 #, no-wrap msgid "texlive" -msgstr "" +msgstr "texlive" #. type: cindex #: doc/guix.texi:6428 #, no-wrap msgid "TeX Live" -msgstr "" +msgstr "TeX Live" #. type: cindex #: doc/guix.texi:6429 #, no-wrap msgid "CTAN" -msgstr "" +msgstr "CTAN" #. type: table #: doc/guix.texi:6433 msgid "Import metadata from @uref{http://www.ctan.org/, CTAN}, the comprehensive TeX archive network for TeX packages that are part of the @uref{https://www.tug.org/texlive/, TeX Live distribution}." -msgstr "" +msgstr "Importe les métadonnées de @uref{http://www.ctan.org/, CTAN}, l'archive TeX réseau complète pour les paquets TeX qui font partie de la @uref{https://www.tug.org/texlive/, distribution TeX Live}." #. type: table #: doc/guix.texi:6438 msgid "Information about the package is obtained through the XML API provided by CTAN, while the source code is downloaded from the SVN repository of the Tex Live project. This is done because the CTAN does not keep versioned archives." -msgstr "" +msgstr "Les informations sur les paquets sont obtenues à travers l'API XML fournie par CTAN, tandis que le code source est téléchargé depuis le dépôt SVN du projet Tex Live. Cette méthode est utilisée parce que CTAN ne garde pas d'archives versionnées." #. type: table #: doc/guix.texi:6441 msgid "The command command below imports metadata for the @code{fontspec} TeX package:" -msgstr "" +msgstr "La commande ci-dessous importe les métadonnées du paquet TeX @code{fontspec} :" #. type: example #: doc/guix.texi:6444 #, no-wrap msgid "guix import texlive fontspec\n" -msgstr "" +msgstr "guix import texlive fontspec\n" #. type: table #: doc/guix.texi:6450 msgid "When @code{--archive=DIRECTORY} is added, the source code is downloaded not from the @file{latex} sub-directory of the @file{texmf-dist/source} tree in the TeX Live SVN repository, but from the specified sibling directory under the same root." -msgstr "" +msgstr "Lorsque l'option @code{--archive=DIRECTORY} est utilisée, le code source n'est pas téléchargé depuis le sous-répertoire @file{latex} du l'arborescence @file{texmf-dist/source} dans le dépôt SVN de TeX Live, mais depuis le répertoire voisin spécifié sous la même racine." #. type: table #: doc/guix.texi:6454 msgid "The command below imports metadata for the @code{ifxetex} package from CTAN while fetching the sources from the directory @file{texmf/source/generic}:" -msgstr "" +msgstr "La commande ci-dessous importe les métadonnées du paquet @code{ifxetex} depuis CTAN en récupérant les sources depuis le répertoire @file{texmf/source/generic} :" #. type: example #: doc/guix.texi:6457 #, no-wrap msgid "guix import texlive --archive=generic ifxetex\n" -msgstr "" +msgstr "guix import texlive --archive=generic ifxetex\n" #. type: item #: doc/guix.texi:6459 #, no-wrap msgid "json" -msgstr "" +msgstr "json" #. type: cindex #: doc/guix.texi:6460 #, no-wrap msgid "JSON, import" -msgstr "" +msgstr "JSON, import" #. type: table #: doc/guix.texi:6465 msgid "Import package metadata from a local JSON file@footnote{This functionality requires Guile-JSON to be installed. @xref{Requirements}.}. Consider the following example package definition in JSON format:" -msgstr "" +msgstr "Importe des métadonnées d'un fichier JSON local@footnote{Cette fonctionnalité requiert l'installation de Guile-JSON. @xref{Requirements}.}. Considérez l'exemple suivant d'une définition de paquet au format JSON :" #. type: example #: doc/guix.texi:6478 @@ -11802,16 +12018,27 @@ msgid "" " \"native-inputs\": [\"gcc@@6\"]\n" "@}\n" msgstr "" +"@{\n" +" \"name\": \"hello\",\n" +" \"version\": \"2.10\",\n" +" \"source\": \"mirror://gnu/hello/hello-2.10.tar.gz\",\n" +" \"build-system\": \"gnu\",\n" +" \"home-page\": \"https://www.gnu.org/software/hello/\",\n" +" \"synopsis\": \"Hello, GNU world: An example GNU package\",\n" +" \"description\": \"GNU Hello prints a greeting.\",\n" +" \"license\": \"GPL-3.0+\",\n" +" \"native-inputs\": [\"gcc@@6\"]\n" +"@}\n" #. type: table #: doc/guix.texi:6484 msgid "The field names are the same as for the @code{} record (@xref{Defining Packages}). References to other packages are provided as JSON lists of quoted package specification strings such as @code{guile} or @code{guile@@2.0}." -msgstr "" +msgstr "Les noms des champs sont les mêmes que pour les enregistrements de @code{} (@xref{Defining Packages}). Les référence à d'autres paquets sont fournies comme des listes JSON de chaînes de spécifications de paquets comme @code{guile} ou @code{guile@@2.0}." #. type: table #: doc/guix.texi:6487 msgid "The importer also supports a more explicit source definition using the common fields for @code{} records:" -msgstr "" +msgstr "L'importateur supporte aussi une définition plus explicite des sources avec les champs habituels pour les enregistrements @code{} :" #. type: example #: doc/guix.texi:6500 @@ -11829,269 +12056,280 @@ msgid "" " @dots{}\n" "@}\n" msgstr "" +"@{\n" +" @dots{}\n" +" \"source\": @{\n" +" \"method\": \"url-fetch\",\n" +" \"uri\": \"mirror://gnu/hello/hello-2.10.tar.gz\",\n" +" \"sha256\": @{\n" +" \"base32\": \"0ssi1wpaf7plaswqqjwigppsg5fyh99vdlb9kzl7c9lng89ndq1i\"\n" +" @}\n" +" @}\n" +" @dots{}\n" +"@}\n" #. type: table #: doc/guix.texi:6504 msgid "The command below reads metadata from the JSON file @code{hello.json} and outputs a package expression:" -msgstr "" +msgstr "La commande ci-dessous lit les métadonnées du fichier JSON @code{hello.json} et renvoie une expression de paquet :" #. type: example #: doc/guix.texi:6507 #, no-wrap msgid "guix import json hello.json\n" -msgstr "" +msgstr "guix import json hello.json\n" #. type: item #: doc/guix.texi:6509 #, no-wrap msgid "nix" -msgstr "" +msgstr "nix" #. type: table #: doc/guix.texi:6518 msgid "Import metadata from a local copy of the source of the @uref{http://nixos.org/nixpkgs/, Nixpkgs distribution}@footnote{This relies on the @command{nix-instantiate} command of @uref{http://nixos.org/nix/, Nix}.}. Package definitions in Nixpkgs are typically written in a mixture of Nix-language and Bash code. This command only imports the high-level package structure that is written in the Nix language. It normally includes all the basic fields of a package definition." -msgstr "" +msgstr "Importe les métadonnées d'une copie locale des source de @uref{http://nixos.org/nixpkgs/, la distribution Nixpkgs}@footnote{Cela repose sur la commande @command{nix-instantiate} de @uref{http://nixos.org/nix/, Nix}.}. Les définitions de paquets dans Nixpkgs sont habituellement écrites en un mélange entre le langage Nix et Bash. Cette commande n'importe que la structure de haut-niveau du paquet qui est écrite dans le langage Nix. Elle inclut normalement tous les champs de base de la définition d'un paquet." #. type: table #: doc/guix.texi:6521 msgid "When importing a GNU package, the synopsis and descriptions are replaced by their canonical upstream variant." -msgstr "" +msgstr "Lorsque vous importez un paquet GNU, le synopsis et la description sont replacés par la version canonique en amont." #. type: table #: doc/guix.texi:6523 msgid "Usually, you will first need to do:" -msgstr "" +msgstr "Normalement, vous devrez d'abord faire :" #. type: example #: doc/guix.texi:6526 #, no-wrap msgid "export NIX_REMOTE=daemon\n" -msgstr "" +msgstr "export NIX_REMOTE=daemon\n" #. type: table #: doc/guix.texi:6530 msgid "so that @command{nix-instantiate} does not try to open the Nix database." -msgstr "" +msgstr "pour que @command{nix-instantiate} n'essaye pas d'ouvrir la base de données de Nix." #. type: table #: doc/guix.texi:6534 msgid "As an example, the command below imports the package definition of LibreOffice (more precisely, it imports the definition of the package bound to the @code{libreoffice} top-level attribute):" -msgstr "" +msgstr "Par exemple, la commande ci-dessous importe la définition du paquet de LibreOffice (plus précisément, elle importe la définition du paquet lié à l'attribut de plus haut-niveau @code{libreoffice}) :" #. type: example #: doc/guix.texi:6537 #, no-wrap msgid "guix import nix ~/path/to/nixpkgs libreoffice\n" -msgstr "" +msgstr "guix import nix ~/path/to/nixpkgs libreoffice\n" #. type: item #: doc/guix.texi:6539 doc/guix.texi:6540 doc/guix.texi:6796 #, no-wrap msgid "hackage" -msgstr "" +msgstr "hackage" #. type: table #: doc/guix.texi:6545 msgid "Import metadata from the Haskell community's central package archive @uref{https://hackage.haskell.org/, Hackage}. Information is taken from Cabal files and includes all the relevant information, including package dependencies." -msgstr "" +msgstr "Importe les métadonnées de l'archive de paquets centrale de la communauté Haskell, @uref{https://hackage.haskell.org/, Hackage}. Les informations sont récupérées depuis les fichiers Cabal et incluent toutes les informations utiles, dont les dépendances des paquets." #. type: item #: doc/guix.texi:6549 #, no-wrap msgid "--stdin" -msgstr "" +msgstr "--stdin" #. type: itemx #: doc/guix.texi:6550 #, no-wrap msgid "-s" -msgstr "" +msgstr "-s" #. type: table #: doc/guix.texi:6552 msgid "Read a Cabal file from standard input." -msgstr "" +msgstr "Lit un fichier Cabal depuis l'entrée standard." #. type: item #: doc/guix.texi:6552 doc/guix.texi:6594 #, no-wrap msgid "--no-test-dependencies" -msgstr "" +msgstr "--no-test-dependencies" #. type: itemx #: doc/guix.texi:6553 doc/guix.texi:6595 #, no-wrap msgid "-t" -msgstr "" +msgstr "-t" #. type: table #: doc/guix.texi:6555 doc/guix.texi:6597 msgid "Do not include dependencies required only by the test suites." -msgstr "" +msgstr "N'inclut pas les dépendances requises uniquement par les suites de tests." #. type: item #: doc/guix.texi:6555 #, no-wrap msgid "--cabal-environment=@var{alist}" -msgstr "" +msgstr "--cabal-environment=@var{alist}" #. type: itemx #: doc/guix.texi:6556 #, no-wrap msgid "-e @var{alist}" -msgstr "" +msgstr "-e @var{alist}" #. type: table #: doc/guix.texi:6565 msgid "@var{alist} is a Scheme alist defining the environment in which the Cabal conditionals are evaluated. The accepted keys are: @code{os}, @code{arch}, @code{impl} and a string representing the name of a flag. The value associated with a flag has to be either the symbol @code{true} or @code{false}. The value associated with other keys has to conform to the Cabal file format definition. The default value associated with the keys @code{os}, @code{arch} and @code{impl} is @samp{linux}, @samp{x86_64} and @samp{ghc}, respectively." -msgstr "" +msgstr "@var{alist} est une alist Scheme qui définie l'environnement dans lequel les conditions de Cabal sont évaluées. Les clefs acceptées sont : @code{os}, @code{arch}, @code{impl} et une représentation sous forme de chaîne de caractères du nom d'un drapeau. La valeur associée à un drapeau doit être le symbole @code{true} ou @code{false}. La valeur associée aux autres clefs doivent se conformer avec la définition du format de fichiers Cabal. La valeur par défaut associée avec les clefs @code{os}, @code{arch} et @code{impl} sont respectivement @samp{linux}, @samp{x86_64} et @samp{ghc}." #. type: table #: doc/guix.texi:6570 msgid "The command below imports metadata for the latest version of the @code{HTTP} Haskell package without including test dependencies and specifying the value of the flag @samp{network-uri} as @code{false}:" -msgstr "" +msgstr "La commande ci-dessous importe les métadonnées de la dernière version du paquet Haskell @code{HTTP} sans inclure les dépendances des tests et en spécifiant la valeur du drapeau @samp{network-uri} comme étant @code{false} :" #. type: example #: doc/guix.texi:6573 #, no-wrap msgid "guix import hackage -t -e \"'((\\\"network-uri\\\" . false))\" HTTP\n" -msgstr "" +msgstr "guix import hackage -t -e \"'((\\\"network-uri\\\" . false))\" HTTP\n" #. type: table #: doc/guix.texi:6577 msgid "A specific package version may optionally be specified by following the package name by an at-sign and a version number as in the following example:" -msgstr "" +msgstr "Une version spécifique du paquet peut éventuellement être spécifiée en faisant suivre le nom du paquet par un arobase et un numéro de version comme dans l'exemple suivant :" #. type: example #: doc/guix.texi:6580 #, no-wrap msgid "guix import hackage mtl@@2.1.3.1\n" -msgstr "" +msgstr "guix import hackage mtl@@2.1.3.1\n" #. type: item #: doc/guix.texi:6582 doc/guix.texi:6583 doc/guix.texi:6798 #, no-wrap msgid "stackage" -msgstr "" +msgstr "stackage" #. type: table #: doc/guix.texi:6590 msgid "The @code{stackage} importer is a wrapper around the @code{hackage} one. It takes a package name, looks up the package version included in a long-term support (LTS) @uref{https://www.stackage.org, Stackage} release and uses the @code{hackage} importer to retrieve its metadata. Note that it is up to you to select an LTS release compatible with the GHC compiler used by Guix." -msgstr "" +msgstr "L'importateur @code{stackage} est une enveloppe autour de l'importateur @code{hackage}. Il prend un nom de paquet, recherche la version incluse dans une version au support étendu (LTS) de @uref{https://www.stackage.org, Stackage} et utilise l'importateur @code{hackage} pour récupérer les métadonnées. Remarquez que c'est à vous de choisir une version LTS compatible avec le compilateur GHC utilisé par Guix." #. type: item #: doc/guix.texi:6597 #, no-wrap msgid "--lts-version=@var{version}" -msgstr "" +msgstr "--lts-version=@var{version}" #. type: itemx #: doc/guix.texi:6598 #, no-wrap msgid "-r @var{version}" -msgstr "" +msgstr "-r @var{version}" #. type: table #: doc/guix.texi:6601 msgid "@var{version} is the desired LTS release version. If omitted the latest release is used." -msgstr "" +msgstr "@var{version} est la version LTS désirée. Si elle est omise, la dernière version est utilisée." #. type: table #: doc/guix.texi:6605 msgid "The command below imports metadata for the @code{HTTP} Haskell package included in the LTS Stackage release version 7.18:" -msgstr "" +msgstr "La commande ci-dessous importe les métadonnées du paquet Haskell @code{HTTP} inclus dans la version LTS 7.18 de Stackage :" #. type: example #: doc/guix.texi:6608 #, no-wrap msgid "guix import stackage --lts-version=7.18 HTTP\n" -msgstr "" +msgstr "guix import stackage --lts-version=7.18 HTTP\n" #. type: item #: doc/guix.texi:6610 doc/guix.texi:6611 doc/guix.texi:6782 #, no-wrap msgid "elpa" -msgstr "" +msgstr "elpa" #. type: table #: doc/guix.texi:6614 msgid "Import metadata from an Emacs Lisp Package Archive (ELPA) package repository (@pxref{Packages,,, emacs, The GNU Emacs Manual})." -msgstr "" +msgstr "Importe les métadonnées du dépôt de paquets ELPA (Emacs Lisp Package Archive) (@pxref{Packages,,, emacs, The GNU Emacs Manual})." #. type: item #: doc/guix.texi:6618 #, no-wrap msgid "--archive=@var{repo}" -msgstr "" +msgstr "--archive=@var{repo}" #. type: itemx #: doc/guix.texi:6619 #, no-wrap msgid "-a @var{repo}" -msgstr "" +msgstr "-a @var{repo}" #. type: table #: doc/guix.texi:6623 msgid "@var{repo} identifies the archive repository from which to retrieve the information. Currently the supported repositories and their identifiers are:" -msgstr "" +msgstr "@var{repo} identifie le dépôt d'archive depuis lequel récupérer les informations. Actuellement les dépôts supportés et leurs identifiants sont :" #. type: itemize #: doc/guix.texi:6627 msgid "@uref{http://elpa.gnu.org/packages, GNU}, selected by the @code{gnu} identifier. This is the default." -msgstr "" +msgstr "@uref{http://elpa.gnu.org/packages, GNU}, qu'on peut choisir avec l'identifiant @code{gnu}. C'est la valeur par défaut." #. type: itemize #: doc/guix.texi:6633 msgid "Packages from @code{elpa.gnu.org} are signed with one of the keys contained in the GnuPG keyring at @file{share/emacs/25.1/etc/package-keyring.gpg} (or similar) in the @code{emacs} package (@pxref{Package Installation, ELPA package signatures,, emacs, The GNU Emacs Manual})." -msgstr "" +msgstr "Les paquets de @code{elpa.gnu.org} avec l'une des clefs contenues dans le porte-clef GnuPG @file{share/emacs/25.1/etc/package-keyring.gpg} (ou similaire) dans le paquet @code{emacs} (@pxref{Package Installation, ELPA package signatures,, emacs, The GNU Emacs Manual})." #. type: itemize #: doc/guix.texi:6637 msgid "@uref{http://stable.melpa.org/packages, MELPA-Stable}, selected by the @code{melpa-stable} identifier." -msgstr "" +msgstr "@uref{http://stable.melpa.org/packages, MELPA-Stable}, qu'on peut sélectionner avec l'identifiant @code{melpa-stable}." #. type: itemize #: doc/guix.texi:6641 msgid "@uref{http://melpa.org/packages, MELPA}, selected by the @code{melpa} identifier." -msgstr "" +msgstr "@uref{http://melpa.org/packages, MELPA}, qu'on peut sélectionner avec l'identifiant @code{melpa}." #. type: table #: doc/guix.texi:6648 msgid "Traverse the dependency graph of the given upstream package recursively and generate package expressions for all those packages that are not yet in Guix." -msgstr "" +msgstr "Traverse le graphe des dépendances du paquet amont donné et génère les expressions de paquets de tous ceux qui ne sont pas déjà dans Guix." #. type: item #: doc/guix.texi:6650 doc/guix.texi:6651 doc/guix.texi:6800 #, no-wrap msgid "crate" -msgstr "" +msgstr "crate" #. type: table #: doc/guix.texi:6654 msgid "Import metadata from the crates.io Rust package repository @uref{https://crates.io, crates.io}." -msgstr "" +msgstr "Importe les métadonnées du répertoire des paquets Rust @uref{https://crates.io, crates.io}." #. type: Plain text #: doc/guix.texi:6659 msgid "The structure of the @command{guix import} code is modular. It would be useful to have more importers for other package formats, and your help is welcome here (@pxref{Contributing})." -msgstr "" +msgstr "La structure du code de @command{guix import} est modulaire. Il serait utile d'avoir plus d'importateurs pour d'autres formats de paquets et votre aide est la bienvenue sur ce sujet (@pxref{Contributing})." #. type: section #: doc/guix.texi:6661 #, no-wrap msgid "Invoking @command{guix refresh}" -msgstr "" +msgstr "Invoquer @command{guix refresh}" #. type: command{#1} #: doc/guix.texi:6663 #, no-wrap msgid "guix refresh" -msgstr "" +msgstr "guix refresh" #. type: Plain text #: doc/guix.texi:6668 msgid "The primary audience of the @command{guix refresh} command is developers of the GNU software distribution. By default, it reports any packages provided by the distribution that are outdated compared to the latest upstream version, like this:" -msgstr "" +msgstr "L'audience première de la commande @command{guix refresh} est l'ensemble des développeurs de la distribution logicielle GNU. Par défaut, elle rapporte les paquets fournis par la distribution qui sont en retard par rapport aux dernières versions disponibles en amont, comme ceci :" #. type: example #: doc/guix.texi:6673 @@ -12101,11 +12339,14 @@ msgid "" "gnu/packages/gettext.scm:29:13: gettext would be upgraded from 0.18.1.1 to 0.18.2.1\n" "gnu/packages/glib.scm:77:12: glib would be upgraded from 2.34.3 to 2.37.0\n" msgstr "" +"$ guix refresh\n" +"gnu/packages/gettext.scm:29:13: gettext serait mis à jour de 0.18.1.1 à 0.18.2.1\n" +"gnu/packages/glib.scm:77:12: glib serait mis à jour de 2.34.3 à 2.37.0\n" #. type: Plain text #: doc/guix.texi:6677 msgid "Alternately, one can specify packages to consider, in which case a warning is emitted for packages that lack an updater:" -msgstr "" +msgstr "Autrement, on peut spécifier les paquets à considérer, auquel cas un avertissement est émis pour les paquets qui n'ont pas de gestionnaire de mise à jour associé :" #. type: example #: doc/guix.texi:6682 @@ -12115,16 +12356,19 @@ msgid "" "gnu/packages/ssh.scm:205:2: warning: no updater for guile-ssh\n" "gnu/packages/guile.scm:136:12: guile would be upgraded from 2.0.12 to 2.0.13\n" msgstr "" +"$ guix refresh coreutils guile guile-ssh\n" +"gnu/packages/ssh.scm:205:2 : avertissement : aucun gestionnaire de mise à jour pour guile-ssh\n" +"gnu/packages/guile.scm:136:12 : guile serait mis à jour de 2.0.12 à 2.0.13\n" #. type: Plain text #: doc/guix.texi:6691 msgid "@command{guix refresh} browses the upstream repository of each package and determines the highest version number of the releases therein. The command knows how to update specific types of packages: GNU packages, ELPA packages, etc.---see the documentation for @option{--type} below. There are many packages, though, for which it lacks a method to determine whether a new upstream release is available. However, the mechanism is extensible, so feel free to get in touch with us to add a new method!" -msgstr "" +msgstr "@command{guix refresh} navigue le dépôt amont de chaque paquet et détermine le numéro de version le plus élevé parmi les versions publiées. La commande sait comment mettre à jour certains types de paquets : les paquets GNU, les paquets ELPA, etc. — voir la documentation pour @option{--type} ci-dessous. Il y a beaucoup de paquet cependant pour lesquels il manque une méthode pour déterminer si une nouvelle version est disponible en amont. Cependant, le mécanisme est extensible, alors n'hésitez pas à nous contacter pour ajouter une nouvelle méthode !" #. type: Plain text #: doc/guix.texi:6696 msgid "Sometimes the upstream name differs from the package name used in Guix, and @command{guix refresh} needs a little help. Most updaters honor the @code{upstream-name} property in package definitions, which can be used to that effect:" -msgstr "" +msgstr "Parfois les noms en amont diffèrent du nom de paquet utilisé par Guix et @command{guix refresh} a besoin d'un peu d'aide. La plupart des gestionnaires de mise à jour honorent la propriété @code{upstream-name} dans les définitions de paquets, ce qui peut être utilisé à cette fin :" #. type: example #: doc/guix.texi:6703 @@ -12136,225 +12380,230 @@ msgid "" " ;; @dots{}\n" " (properties '((upstream-name . \"NetworkManager\")))))\n" msgstr "" +"(define-public network-manager\n" +" (package\n" +" (name \"network-manager\")\n" +" ;; @dots{}\n" +" (properties '((upstream-name . \"NetworkManager\")))))\n" #. type: Plain text #: doc/guix.texi:6715 msgid "When passed @code{--update}, it modifies distribution source files to update the version numbers and source tarball hashes of those package recipes (@pxref{Defining Packages}). This is achieved by downloading each package's latest source tarball and its associated OpenPGP signature, authenticating the downloaded tarball against its signature using @command{gpg}, and finally computing its hash. When the public key used to sign the tarball is missing from the user's keyring, an attempt is made to automatically retrieve it from a public key server; when this is successful, the key is added to the user's keyring; otherwise, @command{guix refresh} reports an error." -msgstr "" +msgstr "Lorsque l'option @code{--update} est utilisée, elle modifie les fichiers source de la distribution pour mettre à jour le numéro de version et le hash de l'archive source de ces recettes de paquets (@pxref{Defining Packages}). Cela est effectué en téléchargeant la dernière version de l'archive des sources de chaque paquet et des signatures associées, en authentifiant l'archive téléchargée avec sa signature en utilisant @command{gpg} puis en calculant son hash. Lorsque la clef publique utilisée pour signer l'archive manque du porte-clefs de l'utilisateur, le gestionnaire tente de la récupérer automatiquement d'un serveur de clef public ; si cela réussi, la clef est ajoutée au porte-clefs de l'utilisateur, sinon @command{guix refresh} rapporte une erreur." #. type: Plain text #: doc/guix.texi:6717 msgid "The following options are supported:" -msgstr "" +msgstr "Les options suivantes sont supportées :" #. type: table #: doc/guix.texi:6725 doc/guix.texi:7312 msgid "This is useful to precisely refer to a package, as in this example:" -msgstr "" +msgstr "C'est utile pour précisément se référer à un paquet, comme dans cet exemple :" #. type: example #: doc/guix.texi:6728 #, no-wrap msgid "guix refresh -l -e '(@@@@ (gnu packages commencement) glibc-final)'\n" -msgstr "" +msgstr "guix refresh -l -e '(@@@@ (gnu packages commencement) glibc-final)'\n" #. type: table #: doc/guix.texi:6732 msgid "This command lists the dependents of the ``final'' libc (essentially all the packages.)" -msgstr "" +msgstr "Cette commande liste les paquets qui dépendent de la libc « finale » (en gros tous les paquets)." #. type: item #: doc/guix.texi:6733 #, no-wrap msgid "--update" -msgstr "" +msgstr "--update" #. type: itemx #: doc/guix.texi:6734 #, no-wrap msgid "-u" -msgstr "" +msgstr "-u" #. type: table #: doc/guix.texi:6738 msgid "Update distribution source files (package recipes) in place. This is usually run from a checkout of the Guix source tree (@pxref{Running Guix Before It Is Installed}):" -msgstr "" +msgstr "Met à jour les fichiers source de la distribution (les recettes de paquets) en place. Cette option est généralement utilisée depuis une copie du dépôt git de Guix (@pxref{Running Guix Before It Is Installed}) :" #. type: example #: doc/guix.texi:6741 #, no-wrap msgid "$ ./pre-inst-env guix refresh -s non-core -u\n" -msgstr "" +msgstr "$ ./pre-inst-env guix refresh -s non-core -u\n" #. type: table #: doc/guix.texi:6744 msgid "@xref{Defining Packages}, for more information on package definitions." -msgstr "" +msgstr "@xref{Defining Packages}, pour plus d'information sur les définitions des paquets." #. type: item #: doc/guix.texi:6745 #, no-wrap msgid "--select=[@var{subset}]" -msgstr "" +msgstr "--select=[@var{subset}]" #. type: itemx #: doc/guix.texi:6746 #, no-wrap msgid "-s @var{subset}" -msgstr "" +msgstr "-s @var{subset}" #. type: table #: doc/guix.texi:6749 msgid "Select all the packages in @var{subset}, one of @code{core} or @code{non-core}." -msgstr "" +msgstr "Choisi tous les paquets dans @var{subset}, entre @code{core} et @code{non-core}." #. type: table #: doc/guix.texi:6756 msgid "The @code{core} subset refers to all the packages at the core of the distribution---i.e., packages that are used to build ``everything else''. This includes GCC, libc, Binutils, Bash, etc. Usually, changing one of these packages in the distribution entails a rebuild of all the others. Thus, such updates are an inconvenience to users in terms of build time or bandwidth used to achieve the upgrade." -msgstr "" +msgstr "Le sous-ensemble @code{core} se réfère à tous les paquets du cœur de la distribution — c.-à-d.@: les paquets qui sont utilisés pour construire « tout le rest ». Cela comprend GCC, libc, Binutils, Bash, etc. Habituellement, changer l'un de ces paquets dans la distribution implique de reconstruire tous les autres. Ainsi, ces mises à jour sont une nuisance pour les utilisateurs, en terme de temps de compilation et de bande passante utilisés pour effectuer la mise à jour." #. type: table #: doc/guix.texi:6760 msgid "The @code{non-core} subset refers to the remaining packages. It is typically useful in cases where an update of the core packages would be inconvenient." -msgstr "" +msgstr "Le sous-ensemble @code{non-core} se réfère au reste des paquets. C'est habituellement utile dans les cas où une mise à jour des paquets du cœur serait dérangeante." #. type: table #: doc/guix.texi:6765 msgid "Select all the packages from the manifest in @var{file}. This is useful to check if any packages of the user manifest can be updated." -msgstr "" +msgstr "Choisi tous les paquets du manifeste dans @var{file}. C'est utile pour vérifier qu'aucun des paquets du manifeste utilisateur ne peut être mis à jour." #. type: item #: doc/guix.texi:6766 #, no-wrap msgid "--type=@var{updater}" -msgstr "" +msgstr "--type=@var{updater}" #. type: itemx #: doc/guix.texi:6767 #, no-wrap msgid "-t @var{updater}" -msgstr "" +msgstr "-t @var{updater}" #. type: table #: doc/guix.texi:6770 msgid "Select only packages handled by @var{updater} (may be a comma-separated list of updaters). Currently, @var{updater} may be one of:" -msgstr "" +msgstr "Chois uniquement les paquets pris en charge par @var{updater} (éventuellement une liste de gestionnaires de mise à jour séparés par des virgules). Actuellement, @var{updater} peut être l'une des valeurs suivantes :" #. type: table #: doc/guix.texi:6774 msgid "the updater for GNU packages;" -msgstr "" +msgstr "le gestionnaire de mise à jour pour les paquets GNU ;" #. type: item #: doc/guix.texi:6774 #, no-wrap msgid "gnome" -msgstr "" +msgstr "gnome" #. type: table #: doc/guix.texi:6776 msgid "the updater for GNOME packages;" -msgstr "" +msgstr "le gestionnaire de mise à jour pour les paquets GNOME ;" #. type: item #: doc/guix.texi:6776 #, no-wrap msgid "kde" -msgstr "" +msgstr "kde" #. type: table #: doc/guix.texi:6778 msgid "the updater for KDE packages;" -msgstr "" +msgstr "le gestionnaire de mise à jour pour les paquets KDE ;" #. type: item #: doc/guix.texi:6778 #, no-wrap msgid "xorg" -msgstr "" +msgstr "xorg" #. type: table #: doc/guix.texi:6780 msgid "the updater for X.org packages;" -msgstr "" +msgstr "le gestionnaire de mise à jour pour les paquets X.org ;" #. type: item #: doc/guix.texi:6780 #, no-wrap msgid "kernel.org" -msgstr "" +msgstr "kernel.org" #. type: table #: doc/guix.texi:6782 msgid "the updater for packages hosted on kernel.org;" -msgstr "" +msgstr "le gestionnaire de mise à jour pour les paquets hébergés sur kernel.org ;" #. type: table #: doc/guix.texi:6784 msgid "the updater for @uref{http://elpa.gnu.org/, ELPA} packages;" -msgstr "" +msgstr "le gestionnaire de mise à jour pour les paquets @uref{http://elpa.gnu.org/, ELPA} ;" #. type: table #: doc/guix.texi:6786 msgid "the updater for @uref{https://cran.r-project.org/, CRAN} packages;" -msgstr "" +msgstr "le gestionnaire de mise à jour pour les paquets @uref{https://cran.r-project.org/, CRAN} ;" #. type: item #: doc/guix.texi:6786 #, no-wrap msgid "bioconductor" -msgstr "" +msgstr "bioconductor" #. type: table #: doc/guix.texi:6788 msgid "the updater for @uref{https://www.bioconductor.org/, Bioconductor} R packages;" -msgstr "" +msgstr "le gestionnaire de mise à jour pour les paquets @uref{https://www.bioconductor.org/, Bioconductor} ;" #. type: table #: doc/guix.texi:6790 msgid "the updater for @uref{http://www.cpan.org/, CPAN} packages;" -msgstr "" +msgstr "le gestionnaire de mise à jour pour les paquets @uref{http://www.cpan.org/, CPAN} ;" #. type: table #: doc/guix.texi:6792 msgid "the updater for @uref{https://pypi.python.org, PyPI} packages." -msgstr "" +msgstr "le gestionnaire de mise à jour pour les paquets @uref{https://pypi.python.org, PyPI} ;" #. type: table #: doc/guix.texi:6794 msgid "the updater for @uref{https://rubygems.org, RubyGems} packages." -msgstr "" +msgstr "le gestionnaire de mise à jour pour les paquets @uref{https://rubygems.org, RubyGems} ;" #. type: item #: doc/guix.texi:6794 #, no-wrap msgid "github" -msgstr "" +msgstr "github" #. type: table #: doc/guix.texi:6796 msgid "the updater for @uref{https://github.com, GitHub} packages." -msgstr "" +msgstr "le gestionnaire de mise à jour pour les paquets @uref{https://github.com, GitHub} ;" #. type: table #: doc/guix.texi:6798 msgid "the updater for @uref{https://hackage.haskell.org, Hackage} packages." -msgstr "" +msgstr "le gestionnaire de mise à jour pour les paquets @uref{https://hackage.haskell.org, Hackage} ;" #. type: table #: doc/guix.texi:6800 msgid "the updater for @uref{https://www.stackage.org, Stackage} packages." -msgstr "" +msgstr "le gestionnaire de mise à jour pour les paquets @uref{https://www.stackage.org, Stackage} ;" #. type: table #: doc/guix.texi:6802 msgid "the updater for @uref{https://crates.io, Crates} packages." -msgstr "" +msgstr "le gestionnaire de mise à jour pour les paquets @uref{https://crates.io, Crates} ;" #. type: table #: doc/guix.texi:6806 msgid "For instance, the following command only checks for updates of Emacs packages hosted at @code{elpa.gnu.org} and for updates of CRAN packages:" -msgstr "" +msgstr "Par exemple, la commande suivante ne vérifie que les mises à jour des paquets Emacs hébergés sur @code{elpa.gnu.org} et les paquets CRAN :" #. type: example #: doc/guix.texi:6811 @@ -12364,76 +12613,79 @@ msgid "" "gnu/packages/statistics.scm:819:13: r-testthat would be upgraded from 0.10.0 to 0.11.0\n" "gnu/packages/emacs.scm:856:13: emacs-auctex would be upgraded from 11.88.6 to 11.88.9\n" msgstr "" +"$ guix refresh --type=elpa,cran\n" +"gnu/packages/statistics.scm:819:13 : r-testthat serait mis à jour de 0.10.0 à 0.11.0\n" +"gnu/packages/emacs.scm:856:13 : emacs-auctex serait mis à jour de 11.88.6 à 11.88.9\n" #. type: Plain text #: doc/guix.texi:6817 msgid "In addition, @command{guix refresh} can be passed one or more package names, as in this example:" -msgstr "" +msgstr "En plus, on peut passer à @command{guix refresh} un ou plusieurs noms de paquets, comme dans cet exemple :" #. type: example #: doc/guix.texi:6820 #, no-wrap msgid "$ ./pre-inst-env guix refresh -u emacs idutils gcc@@4.8\n" -msgstr "" +msgstr "$ ./pre-inst-env guix refresh -u emacs idutils gcc@@4.8\n" #. type: Plain text #: doc/guix.texi:6826 msgid "The command above specifically updates the @code{emacs} and @code{idutils} packages. The @code{--select} option would have no effect in this case." -msgstr "" +msgstr "La commande au-dessus met à jour spécifiquement les paquets @code{emacs} et @code{idutils}. L'option @code{--select} n'aurait aucun effet dans ce cas." #. type: Plain text #: doc/guix.texi:6831 msgid "When considering whether to upgrade a package, it is sometimes convenient to know which packages would be affected by the upgrade and should be checked for compatibility. For this the following option may be used when passing @command{guix refresh} one or more package names:" -msgstr "" +msgstr "Pour déterminer s'il faut mettre à jour un paquet, il est parfois pratique de savoir quels paquets seraient affectés par la mise à jour pour pouvoir vérifier la compatibilité. Pour cela l'option suivante peut être utilisée avec un ou plusieurs noms de paquets passés à @command{guix refresh} :" #. type: item #: doc/guix.texi:6834 #, no-wrap msgid "--list-updaters" -msgstr "" +msgstr "--list-updaters" #. type: itemx #: doc/guix.texi:6835 #, no-wrap msgid "-L" -msgstr "" +msgstr "-L" #. type: table #: doc/guix.texi:6837 msgid "List available updaters and exit (see @option{--type} above.)" -msgstr "" +msgstr "Liste les gestionnaires de mise à jour et quitte (voir l'option @option{--type} plus haut)." #. type: table #: doc/guix.texi:6840 msgid "For each updater, display the fraction of packages it covers; at the end, display the fraction of packages covered by all these updaters." -msgstr "" +msgstr "Pour chaque gestionnaire, affiche le pourcentage de paquets qu'il couvre ; à la fin, affiche le pourcentage de paquets couverts par tous les gestionnaires." #. type: item #: doc/guix.texi:6841 #, no-wrap msgid "--list-dependent" -msgstr "" +msgstr "--list-dependent" #. type: itemx #: doc/guix.texi:6842 doc/guix.texi:7005 #, no-wrap msgid "-l" -msgstr "" +msgstr "-l" #. type: table #: doc/guix.texi:6845 msgid "List top-level dependent packages that would need to be rebuilt as a result of upgrading one or more packages." -msgstr "" +msgstr "Liste les paquets de plus haut-niveau qui devraient être reconstruits après la mise à jour d'un ou plusieurs paquets." #. type: table #: doc/guix.texi:6849 msgid "@xref{Invoking guix graph, the @code{reverse-package} type of @command{guix graph}}, for information on how to visualize the list of dependents of a package." -msgstr "" +msgstr "@xref{Invoking guix graph, le type @code{reverse-package} de @command{guix graph}}, pour des informations sur la manière de visualiser la liste des paquets dépendant d'un autre." #. type: Plain text #: doc/guix.texi:6855 msgid "Be aware that the @code{--list-dependent} option only @emph{approximates} the rebuilds that would be required as a result of an upgrade. More rebuilds might be required under some circumstances." -msgstr "" +msgstr "Soyez conscients que l'option @code{--list-dependent} ne fait @emph{qu'approximer} les reconstructions qui seraient requises par une mise à jour. Plus de reconstructions pourraient être requises dans certaines circonstances." #. type: example #: doc/guix.texi:6860 @@ -12443,185 +12695,188 @@ msgid "" "Building the following 120 packages would ensure 213 dependent packages are rebuilt:\n" "hop@@2.4.0 geiser@@0.4 notmuch@@0.18 mu@@0.9.9.5 cflow@@1.4 idutils@@4.6 @dots{}\n" msgstr "" +"$ guix refresh --list-dependent flex\n" +"Building the following 120 packages would ensure 213 dependent packages are rebuilt:\n" +"hop@@2.4.0 geiser@@0.4 notmuch@@0.18 mu@@0.9.9.5 cflow@@1.4 idutils@@4.6 @dots{}\n" #. type: Plain text #: doc/guix.texi:6864 msgid "The command above lists a set of packages that could be built to check for compatibility with an upgraded @code{flex} package." -msgstr "" +msgstr "La commande ci-dessus liste un ensemble de paquets qui peuvent être construits pour vérifier la compatibilité d'une mise à jour de @code{flex}." #. type: Plain text #: doc/guix.texi:6866 msgid "The following options can be used to customize GnuPG operation:" -msgstr "" +msgstr "Les options suivante peuvent être utilisées pour personnaliser les opérations avec GnuPG :" #. type: item #: doc/guix.texi:6869 #, no-wrap msgid "--gpg=@var{command}" -msgstr "" +msgstr "--gpg=@var{commande}" #. type: table #: doc/guix.texi:6872 msgid "Use @var{command} as the GnuPG 2.x command. @var{command} is searched for in @code{$PATH}." -msgstr "" +msgstr "Utilise @var{commande} comme la commande de GnuPG 2.x. @var{commande} est recherchée dans @code{PATH}." #. type: table #: doc/guix.texi:6876 msgid "Handle missing OpenPGP keys according to @var{policy}, which may be one of:" -msgstr "" +msgstr "Gère les clefs OpenPGP manquantes d'après la @var{politique}, qui peut être l'une des suivantes :" #. type: item #: doc/guix.texi:6878 doc/guix.texi:14077 #, no-wrap msgid "always" -msgstr "" +msgstr "always" #. type: table #: doc/guix.texi:6881 msgid "Always download missing OpenPGP keys from the key server, and add them to the user's GnuPG keyring." -msgstr "" +msgstr "Toujours télécharger les clefs manquantes depuis un serveur de clefs et les ajouter au porte-clefs de l'utilisateur." #. type: item #: doc/guix.texi:6882 doc/guix.texi:14079 #, no-wrap msgid "never" -msgstr "" +msgstr "never" #. type: table #: doc/guix.texi:6884 msgid "Never try to download missing OpenPGP keys. Instead just bail out." -msgstr "" +msgstr "Ne jamais essayer de télécharger les clefs OpenPGP manquante. Quitter à la place." #. type: item #: doc/guix.texi:6885 #, no-wrap msgid "interactive" -msgstr "" +msgstr "interactive" #. type: table #: doc/guix.texi:6888 msgid "When a package signed with an unknown OpenPGP key is encountered, ask the user whether to download it or not. This is the default behavior." -msgstr "" +msgstr "Lorsqu'on rencontre un paquet signé par une clef OpenPGP inconnue, demander à l'utilisateur s'il souhaite la télécharger ou non. C'est le comportement par défaut." #. type: item #: doc/guix.texi:6890 #, no-wrap msgid "--key-server=@var{host}" -msgstr "" +msgstr "--key-server=@var{host}" #. type: table #: doc/guix.texi:6892 msgid "Use @var{host} as the OpenPGP key server when importing a public key." -msgstr "" +msgstr "Utiliser @var{host} comme serveur de clefs OpenPGP lors de l'importe d'une clef publique." #. type: Plain text #: doc/guix.texi:6905 msgid "The @code{github} updater uses the @uref{https://developer.github.com/v3/, GitHub API} to query for new releases. When used repeatedly e.g. when refreshing all packages, GitHub will eventually refuse to answer any further API requests. By default 60 API requests per hour are allowed, and a full refresh on all GitHub packages in Guix requires more than this. Authentication with GitHub through the use of an API token alleviates these limits. To use an API token, set the environment variable @code{GUIX_GITHUB_TOKEN} to a token procured from @uref{https://github.com/settings/tokens} or otherwise." -msgstr "" +msgstr "Le gestionnaire de mises à jour @code{github} utilise @uref{https://developer.github.com/v3/, l'API de GitHub} pour faire des requêtes sur les nouvelles versions. Lorsqu'elle est utilisé de manière répétée, p.@: ex.@: lorsque vous vérifiez tous les paquets, GitHub finira par refuser de répondre à d'autres requêtes de l'API. Par défaut 60 requêtes à l'heure sont autorisées, et une vérification complète de tous les paquets GitHub dans Guix requiert bien plus que cela. L'authentification avec GitHub à travers l'utilisation d'un jeton d'API lève ces limites. Pour utiliser un jeton de l'API, initialisez la variable d'environnement @code{GUIX_GITHUB_TOKEN} avec un jeton que vous vous serez procuré sur @uref{https://github.com/settings/tokens} ou autrement." #. type: section #: doc/guix.texi:6908 #, no-wrap msgid "Invoking @command{guix lint}" -msgstr "" +msgstr "Invoquer @command{guix lint}" #. type: command{#1} #: doc/guix.texi:6910 #, no-wrap msgid "guix lint" -msgstr "" +msgstr "guix lint" #. type: cindex #: doc/guix.texi:6911 #, no-wrap msgid "package, checking for errors" -msgstr "" +msgstr "paquets, chercher des erreurs" #. type: Plain text #: doc/guix.texi:6917 msgid "The @command{guix lint} command is meant to help package developers avoid common errors and use a consistent style. It runs a number of checks on a given set of packages in order to find common mistakes in their definitions. Available @dfn{checkers} include (see @code{--list-checkers} for a complete list):" -msgstr "" +msgstr "La commande @command{guix lint} est conçue pour aider les développeurs à éviter des erreurs commune et à utiliser un style cohérent lors de l'écriture de recettes de paquets. Elle lance des vérifications sur un ensemble de paquets donnés pour trouver des erreurs communes dans leur définition. Les @dfn{vérifieurs} disponibles comprennent (voir @code{--list-checkers} pour une liste complète) :" #. type: table #: doc/guix.texi:6923 msgid "Validate certain typographical and stylistic rules about package descriptions and synopses." -msgstr "" +msgstr "Vérifie certaines règles typographiques et stylistiques dans les descriptions et les synopsis." #. type: item #: doc/guix.texi:6924 #, no-wrap msgid "inputs-should-be-native" -msgstr "" +msgstr "inputs-should-be-native" #. type: table #: doc/guix.texi:6926 msgid "Identify inputs that should most likely be native inputs." -msgstr "" +msgstr "Identifie les entrées qui devraient sans doute plutôt être des entrées natives." #. type: itemx #: doc/guix.texi:6929 #, no-wrap msgid "mirror-url" -msgstr "" +msgstr "mirror-url" #. type: itemx #: doc/guix.texi:6930 #, no-wrap msgid "source-file-name" -msgstr "" +msgstr "source-file-name" #. type: table #: doc/guix.texi:6936 msgid "Probe @code{home-page} and @code{source} URLs and report those that are invalid. Suggest a @code{mirror://} URL when applicable. Check that the source file name is meaningful, e.g. is not just a version number or ``git-checkout'', without a declared @code{file-name} (@pxref{origin Reference})." -msgstr "" +msgstr "Sonde les URL @code{home-page} et @code{source} et rapporte celles qui sont invalides. Suggère une URL en @code{mirror://} lorsque c'est possible. Vérifie que le nom du fichier source a un sens, p.@: ex.@: qu'il ne s'agisse pas juste d'un numéro de version ou « git-checkou », sans avoir déclaré un @code{file-name} (@pxref{origin Reference})." #. type: item #: doc/guix.texi:6937 #, no-wrap msgid "cve" -msgstr "" +msgstr "cve" #. type: cindex #: doc/guix.texi:6938 doc/guix.texi:21969 #, no-wrap msgid "security vulnerabilities" -msgstr "" +msgstr "vulnérabilités" #. type: cindex #: doc/guix.texi:6939 #, no-wrap msgid "CVE, Common Vulnerabilities and Exposures" -msgstr "" +msgstr "CVE, Common Vulnerabilities and Exposures" #. type: table #: doc/guix.texi:6944 msgid "Report known vulnerabilities found in the Common Vulnerabilities and Exposures (CVE) databases of the current and past year @uref{https://nvd.nist.gov/download.cfm#CVE_FEED, published by the US NIST}." -msgstr "" +msgstr "Rapporte les vulnérabilités connues trouvées dans les bases de données CVE (Common Vulnerabilities and Exposures) de l'année en cours et des années précédentes @uref{https://nvd.nist.gov/download.cfm#CVE_FEED, publié par le NIST américain}." #. type: table #: doc/guix.texi:6946 msgid "To view information about a particular vulnerability, visit pages such as:" -msgstr "" +msgstr "Pour voir les informations sur une vulnérabilité en particulier, visitez les pages :" #. type: indicateurl{#1} #: doc/guix.texi:6950 msgid "https://web.nvd.nist.gov/view/vuln/detail?vulnId=CVE-YYYY-ABCD" -msgstr "" +msgstr "https://web.nvd.nist.gov/view/vuln/detail?vulnId=CVE-ANNÉE-ABCD" #. type: indicateurl{#1} #: doc/guix.texi:6952 msgid "https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-YYYY-ABCD" -msgstr "" +msgstr "https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-ANNÉE-ABCD" #. type: table #: doc/guix.texi:6957 msgid "where @code{CVE-YYYY-ABCD} is the CVE identifier---e.g., @code{CVE-2015-7554}." -msgstr "" +msgstr "où @code{CVE-ANNÉE-ABCD} est l'identifiant CVE — p.@: ex.@: @code{CVE-2015-7554}." #. type: table #: doc/guix.texi:6962 msgid "Package developers can specify in package recipes the @uref{https://nvd.nist.gov/cpe.cfm,Common Platform Enumeration (CPE)} name and version of the package when they differ from the name or version that Guix uses, as in this example:" -msgstr "" +msgstr "Les développeurs de paquets peuvent spécifier dans les recettes des paquets le nom @uref{https://nvd.nist.gov/cpe.cfm,CPE (Common Platform Enumeration)} et la version du paquet s'ils diffèrent du nom et de la version que Guix utilise, comme dans cet exemple :" #. type: example #: doc/guix.texi:6970 @@ -12634,11 +12889,17 @@ msgid "" " (properties '((cpe-name . \"grub2\")\n" " (cpe-version . \"2.3\")))\n" msgstr "" +"(package\n" +" (name \"grub\")\n" +" ;; @dots{}\n" +" ;; CPE calls this package \"grub2\".\n" +" (properties '((cpe-name . \"grub2\")\n" +" (cpe-version . \"2.3\")))\n" #. type: table #: doc/guix.texi:6977 msgid "Some entries in the CVE database do not specify which version of a package they apply to, and would thus ``stick around'' forever. Package developers who found CVE alerts and verified they can be ignored can declare them as in this example:" -msgstr "" +msgstr "Certaines entrées dans la base de données CVE ne spécifient pas la version du paquet auquel elles s'appliquent et lui restera donc attachée pour toujours. Les développeurs qui trouvent des alertes CVE et ont vérifiés qu'elles peuvent être ignorées peuvent les déclarer comme dans cet exemple :" #. type: example #: doc/guix.texi:6987 @@ -12653,90 +12914,98 @@ msgid "" " \"CVE-2011-1554\"\n" " \"CVE-2011-5244\")))))\n" msgstr "" +"(package\n" +" (name \"t1lib\")\n" +" ;; @dots{}\n" +" ;; Ces CVE ne s'appliquent plus et peuvent être ignorée sans problème.\n" +" (properties `((lint-hidden-cve . (\"CVE-2011-0433\"\n" +" \"CVE-2011-1553\"\n" +" \"CVE-2011-1554\"\n" +" \"CVE-2011-5244\")))))\n" #. type: item #: doc/guix.texi:6989 #, no-wrap msgid "formatting" -msgstr "" +msgstr "formatting" #. type: table #: doc/guix.texi:6992 msgid "Warn about obvious source code formatting issues: trailing white space, use of tabulations, etc." -msgstr "" +msgstr "Avertit le développeurs lorsqu'il y a des problèmes de formatage du code source évident : des espaces en fin de ligne, des tabulations, etc." #. type: example #: doc/guix.texi:6998 #, no-wrap msgid "guix lint @var{options} @var{package}@dots{}\n" -msgstr "" +msgstr "guix lint @var{options} @var{package}@dots{}\n" #. type: Plain text #: doc/guix.texi:7002 msgid "If no package is given on the command line, then all packages are checked. The @var{options} may be zero or more of the following:" -msgstr "" +msgstr "Si aucun paquet n'est donné par la ligne de commande, tous les paquets seront vérifiés. Les @var{options} peuvent contenir aucune ou plus des options suivantes :" #. type: item #: doc/guix.texi:7004 #, no-wrap msgid "--list-checkers" -msgstr "" +msgstr "--list-checkers" #. type: table #: doc/guix.texi:7008 msgid "List and describe all the available checkers that will be run on packages and exit." -msgstr "" +msgstr "Liste et décrit tous les vérificateurs disponibles qui seront lancés sur les paquets puis quitte." #. type: item #: doc/guix.texi:7009 #, no-wrap msgid "--checkers" -msgstr "" +msgstr "--checkers" #. type: itemx #: doc/guix.texi:7010 #, no-wrap msgid "-c" -msgstr "" +msgstr "-c" #. type: table #: doc/guix.texi:7013 msgid "Only enable the checkers specified in a comma-separated list using the names returned by @code{--list-checkers}." -msgstr "" +msgstr "N'active que les vérificateurs spécifiés dans une liste de noms séparés par des virgules parmi la liste renvoyée par @code{--list-checkers}." #. type: section #: doc/guix.texi:7017 #, no-wrap msgid "Invoking @command{guix size}" -msgstr "" +msgstr "Invoquer @command{guix size}" #. type: cindex #: doc/guix.texi:7019 #, no-wrap msgid "size" -msgstr "" +msgstr "taille" #. type: cindex #: doc/guix.texi:7020 #, no-wrap msgid "package size" -msgstr "" +msgstr "paquet, taille" #. type: command{#1} #: doc/guix.texi:7022 #, no-wrap msgid "guix size" -msgstr "" +msgstr "guix size" #. type: Plain text #: doc/guix.texi:7029 msgid "The @command{guix size} command helps package developers profile the disk usage of packages. It is easy to overlook the impact of an additional dependency added to a package, or the impact of using a single output for a package that could easily be split (@pxref{Packages with Multiple Outputs}). Such are the typical issues that @command{guix size} can highlight." -msgstr "" +msgstr "La commande @command{guix size} aide les développeurs à dresser un profil de l'utilisation du disque que font les paquets. C'est facile de négliger l'impact d'une dépendance supplémentaire ajoutée à un paquet, ou l'impact de l'utilisation d'une sortie unique pour un paquet qui pourrait être facilement séparé (@pxref{Packages with Multiple Outputs}). Ce sont les problèmes que @command{guix size} peut typiquement mettre en valeur." #. type: Plain text #: doc/guix.texi:7034 msgid "The command can be passed one or more package specifications such as @code{gcc@@4.8} or @code{guile:debug}, or a file name in the store. Consider this example:" -msgstr "" +msgstr "On peut passer un ou plusieurs spécifications de paquets à la commande, comme @code{gcc@@4.8} ou @code{guile:debug}, ou un nom de fichier dans le dépôt. Regardez cet exemple :" #. type: example #: doc/guix.texi:7047 @@ -12754,32 +13023,43 @@ msgid "" "/gnu/store/@dots{}-libcap-2.25 60.5 0.2 0.2%\n" "total: 78.9 MiB\n" msgstr "" +"$ guix size coreutils\n" +"store item total self\n" +"/gnu/store/@dots{}-gcc-5.5.0-lib 60.4 30.1 38.1%\n" +"/gnu/store/@dots{}-glibc-2.27 30.3 28.8 36.6%\n" +"/gnu/store/@dots{}-coreutils-8.28 78.9 15.0 19.0%\n" +"/gnu/store/@dots{}-gmp-6.1.2 63.1 2.7 3.4%\n" +"/gnu/store/@dots{}-bash-static-4.4.12 1.5 1.5 1.9%\n" +"/gnu/store/@dots{}-acl-2.2.52 61.1 0.4 0.5%\n" +"/gnu/store/@dots{}-attr-2.4.47 60.6 0.2 0.3%\n" +"/gnu/store/@dots{}-libcap-2.25 60.5 0.2 0.2%\n" +"total: 78.9 MiB\n" #. type: Plain text #: doc/guix.texi:7053 msgid "The store items listed here constitute the @dfn{transitive closure} of Coreutils---i.e., Coreutils and all its dependencies, recursively---as would be returned by:" -msgstr "" +msgstr "Les éléments du dépôt listés ici constituent la @dfn{cloture transitive} de Coreutils — c.-à-d.@: Coreutils et toutes ses dépendances, récursivement — comme ce qui serait renvoyé par :" #. type: example #: doc/guix.texi:7056 #, no-wrap msgid "$ guix gc -R /gnu/store/@dots{}-coreutils-8.23\n" -msgstr "" +msgstr "$ guix gc -R /gnu/store/@dots{}-coreutils-8.23\n" #. type: Plain text #: doc/guix.texi:7064 msgid "Here the output shows three columns next to store items. The first column, labeled ``total'', shows the size in mebibytes (MiB) of the closure of the store item---that is, its own size plus the size of all its dependencies. The next column, labeled ``self'', shows the size of the item itself. The last column shows the ratio of the size of the item itself to the space occupied by all the items listed here." -msgstr "" +msgstr "Ici, la sortie possède trois colonnes à côté de chaque élément du dépôt. La première colonne, nommée « total », montre la taille en mébioctet (Mio) de la cloture de l'élément du dépôt — c'est-à-dire sa propre taille plus la taille de ses dépendances. La colonne suivante, nommée « lui-même », montre la taille de l'élément lui-même. La dernière colonne montre le ration de la taille de l'élément lui-même par rapport à celle de tous les éléments montrés." #. type: Plain text #: doc/guix.texi:7070 msgid "In this example, we see that the closure of Coreutils weighs in at 79@tie{}MiB, most of which is taken by libc and GCC's run-time support libraries. (That libc and GCC's libraries represent a large fraction of the closure is not a problem @i{per se} because they are always available on the system anyway.)" -msgstr "" +msgstr "Dans cet exemple, on voit que la cloture de Coreutils pèse 79@tie{}Mio, dont la plupart est dû à la libc et aux bibliothèques à l'exécution de GCC (ce n'est pas un problème en soit que la libc et les bibliothèques de GCC représentent une grande part de la cloture parce qu'elles sont toujours disponibles sur le système de toute façon)." #. type: Plain text #: doc/guix.texi:7079 msgid "When the package(s) passed to @command{guix size} are available in the store@footnote{More precisely, @command{guix size} looks for the @emph{ungrafted} variant of the given package(s), as returned by @code{guix build @var{package} --no-grafts}. @xref{Security Updates}, for information on grafts.}, @command{guix size} queries the daemon to determine its dependencies, and measures its size in the store, similar to @command{du -ms --apparent-size} (@pxref{du invocation,,, coreutils, GNU Coreutils})." -msgstr "" +msgstr "Lorsque les paquets passés à @command{guix size} sont disponibles dans le dépôt@footnote{Plus précisément, @command{guix size} cherche les variantes @emph{non greffées} des paquets donnés, tels qu'ils sont renvoyés par @code{guix build @var{paquet} --no-graft}. @xref{Security Updates} pour des informations sur les greffes}, @command{guix size} demande au démon de déterminer ses dépendances, et mesure sa taille dans le dépôt, comme avec @command{du -ms --apparent-size} (@pxref{du invocation,,, coreutils, GNU Coreutils})." #. type: Plain text #: doc/guix.texi:7084 @@ -12789,7 +13069,7 @@ msgstr "Lorsque les paquets donnés ne sont @emph{pas} dans le dépôt, @command #. type: Plain text #: doc/guix.texi:7086 msgid "You can also specify several package names:" -msgstr "" +msgstr "Vous pouvez aussi spécifier plusieurs noms de paquets :" #. type: example #: doc/guix.texi:7096 @@ -12804,251 +13084,259 @@ msgid "" "@dots{}\n" "total: 102.3 MiB\n" msgstr "" +"$ guix size coreutils grep sed bash\n" +"store item total self\n" +"/gnu/store/@dots{}-coreutils-8.24 77.8 13.8 13.4%\n" +"/gnu/store/@dots{}-grep-2.22 73.1 0.8 0.8%\n" +"/gnu/store/@dots{}-bash-4.3.42 72.3 4.7 4.6%\n" +"/gnu/store/@dots{}-readline-6.3 67.6 1.2 1.2%\n" +"@dots{}\n" +"total: 102.3 MiB\n" #. type: Plain text #: doc/guix.texi:7102 msgid "In this example we see that the combination of the four packages takes 102.3@tie{}MiB in total, which is much less than the sum of each closure since they have a lot of dependencies in common." -msgstr "" +msgstr "Dans cet exemple on voit que la combinaison des quatre paquets prent 102.3@tie{}Mio en tout, ce qui est bien moins que la somme des clotures puisqu'ils ont beaucoup de dépendances en commun." #. type: Plain text #: doc/guix.texi:7104 msgid "The available options are:" -msgstr "" +msgstr "Les options disponibles sont :" #. type: table #: doc/guix.texi:7110 msgid "Use substitute information from @var{urls}. @xref{client-substitute-urls, the same option for @code{guix build}}." -msgstr "" +msgstr "Utilise les informations de substituts de @var{urls}. @xref{client-substitute-urls, the same option for @code{guix build}}." #. type: item #: doc/guix.texi:7111 #, no-wrap msgid "--sort=@var{key}" -msgstr "" +msgstr "--sort=@var{clef}" #. type: table #: doc/guix.texi:7113 msgid "Sort lines according to @var{key}, one of the following options:" -msgstr "" +msgstr "Trie les lignes en fonction de la @var{clef}, l'une des optinos suivantes :" #. type: item #: doc/guix.texi:7115 #, no-wrap msgid "self" -msgstr "" +msgstr "self" #. type: table #: doc/guix.texi:7117 msgid "the size of each item (the default);" -msgstr "" +msgstr "la taille de chaque élément (par défaut) ;" #. type: table #: doc/guix.texi:7119 msgid "the total size of the item's closure." -msgstr "" +msgstr "la taille totale de la cloture de l'élémente." #. type: item #: doc/guix.texi:7121 #, no-wrap msgid "--map-file=@var{file}" -msgstr "" +msgstr "--map-file=@var{fichier} " #. type: table #: doc/guix.texi:7123 msgid "Write a graphical map of disk usage in PNG format to @var{file}." -msgstr "" +msgstr "Écrit un schéma de l'utilisation du disque au format PNG dans @var{fichier}." #. type: table #: doc/guix.texi:7125 msgid "For the example above, the map looks like this:" -msgstr "" +msgstr "Pour l'exemple au-dessus, le schéma ressemble à ceci :" #. type: table #: doc/guix.texi:7128 msgid "@image{images/coreutils-size-map,5in,, map of Coreutils disk usage produced by @command{guix size}}" -msgstr "" +msgstr "@image{images/coreutils-size-map,5in,, schéma de l'utilisation du disque de Coreutils produit par @command{guix size}}" #. type: table #: doc/guix.texi:7133 msgid "This option requires that @uref{http://wingolog.org/software/guile-charting/, Guile-Charting} be installed and visible in Guile's module search path. When that is not the case, @command{guix size} fails as it tries to load it." -msgstr "" +msgstr "Cette option requiert l'installation de @uref{http://wingolog.org/software/guile-charting/, Guile-Charting} et qu'il soit visible dans le chemin de recherche des modules Guile. Lorsque ce n'est pas le cas, @command{guix size} plante en essayant de le charger." #. type: table #: doc/guix.texi:7137 msgid "Consider packages for @var{system}---e.g., @code{x86_64-linux}." -msgstr "" +msgstr "Considère les paquets pour @var{système} — p.@: ex.@: @code{x86_64-linux}." #. type: section #: doc/guix.texi:7141 #, no-wrap msgid "Invoking @command{guix graph}" -msgstr "" +msgstr "Invoque @command{guix graph}" #. type: cindex #: doc/guix.texi:7143 #, no-wrap msgid "DAG" -msgstr "" +msgstr "DAG" #. type: command{#1} #: doc/guix.texi:7144 #, no-wrap msgid "guix graph" -msgstr "" +msgstr "guix graph" #. type: Plain text #: doc/guix.texi:7158 msgid "Packages and their dependencies form a @dfn{graph}, specifically a directed acyclic graph (DAG). It can quickly become difficult to have a mental model of the package DAG, so the @command{guix graph} command provides a visual representation of the DAG. By default, @command{guix graph} emits a DAG representation in the input format of @uref{http://www.graphviz.org/, Graphviz}, so its output can be passed directly to the @command{dot} command of Graphviz. It can also emit an HTML page with embedded JavaScript code to display a ``chord diagram'' in a Web browser, using the @uref{https://d3js.org/, d3.js} library, or emit Cypher queries to construct a graph in a graph database supporting the @uref{http://www.opencypher.org/, openCypher} query language. The general syntax is:" -msgstr "" +msgstr "Les paquets et leurs dépendances forment un @dfn{graphe}, plus précisément un graphe orienté acyclique (DAG). Il peut vite devenir difficile d'avoir une représentation mentale du DAG d'un paquet, donc la commande @command{guix graph} fournit une représentation visuelle du DAG. Par défaut, @command{guix graph} émet un représentation du DAG dans le format d'entrée de @uref{http://www.graphviz.org/, Graphviz}, pour que sa sortie puisse être passée directement à la commande @command{dot} de Graphviz. Elle peut aussi émettre une page HTML avec du code Javascript pour afficher un « digramme d'accords » dans un navigateur Web, grâce à la bibliothèque @uref{https://d3js.org/, d3.js}, ou émettre des requêtes Cypher pour construire un graphe dans une base de donnée de graphes supportant le langage de requêtes @uref{http://www.opencypher.org/, openCypher}. La syntaxe générale est :" #. type: example #: doc/guix.texi:7161 #, no-wrap msgid "guix graph @var{options} @var{package}@dots{}\n" -msgstr "" +msgstr "guix graph @var{options} @var{paquet}@dots{}\n" #. type: Plain text #: doc/guix.texi:7166 msgid "For example, the following command generates a PDF file representing the package DAG for the GNU@tie{}Core Utilities, showing its build-time dependencies:" -msgstr "" +msgstr "Par exemple, la commande suivante génère un fichier PDF représentant le DAG du paquet pour GNU@tie{}Core Utilities, qui montre ses dépendances à la compilation :" #. type: example #: doc/guix.texi:7169 #, no-wrap msgid "guix graph coreutils | dot -Tpdf > dag.pdf\n" -msgstr "" +msgstr "guix graph coreutils | dot -Tpdf > dag.pdf\n" #. type: Plain text #: doc/guix.texi:7172 msgid "The output looks like this:" -msgstr "" +msgstr "La sortie ressemble à ceci :" #. type: Plain text #: doc/guix.texi:7174 msgid "@image{images/coreutils-graph,2in,,Dependency graph of the GNU Coreutils}" -msgstr "" +msgstr "@image{images/coreutils-graph,2in,,Graphe de dépendance de GNU Coreutils}" #. type: Plain text #: doc/guix.texi:7176 msgid "Nice little graph, no?" -msgstr "" +msgstr "Joli petit graphe, non ?" #. type: Plain text #: doc/guix.texi:7182 msgid "But there is more than one graph! The one above is concise: it is the graph of package objects, omitting implicit inputs such as GCC, libc, grep, etc. It is often useful to have such a concise graph, but sometimes one may want to see more details. @command{guix graph} supports several types of graphs, allowing you to choose the level of detail:" -msgstr "" +msgstr "Mais il y a plus qu'un seul graphe ! Celui au-dessus est concis : c'est le graphe des objets paquets, en omettant les entrées implicites comme GCC, libc, grep, etc. Il est souvent utile d'avoir ces graphes concis, mais parfois on veut voir plus de détails. @command{guix graph} supporte plusieurs types de graphes, qui vous permettent de choisir le niveau de détails :" #. type: table #: doc/guix.texi:7188 msgid "This is the default type used in the example above. It shows the DAG of package objects, excluding implicit dependencies. It is concise, but filters out many details." -msgstr "" +msgstr "C'est le type par défaut utilisé dans l'exemple plus haut. Il montre le DAG des objets paquets, sans les dépendances implicites. C'est concis, mais omet pas mal de détails." #. type: item #: doc/guix.texi:7189 #, no-wrap msgid "reverse-package" -msgstr "" +msgstr "reverse-package" #. type: table #: doc/guix.texi:7191 msgid "This shows the @emph{reverse} DAG of packages. For example:" -msgstr "" +msgstr "Cela montre le DAG @emph{inversé} des paquets. Par exemple :" #. type: example #: doc/guix.texi:7194 #, no-wrap msgid "guix graph --type=reverse-package ocaml\n" -msgstr "" +msgstr "guix graph --type=reverse-package ocaml\n" #. type: table #: doc/guix.texi:7197 msgid "... yields the graph of packages that depend on OCaml." -msgstr "" +msgstr "… montre le graphe des paquets qui dépendent de OCaml." #. type: table #: doc/guix.texi:7202 msgid "Note that for core packages this can yield huge graphs. If all you want is to know the number of packages that depend on a given package, use @command{guix refresh --list-dependent} (@pxref{Invoking guix refresh, @option{--list-dependent}})." -msgstr "" +msgstr "Remarquez que pour les paquets du cœur de la distribution, cela crée des graphes énormes. Si vous voulez seulement voir le nombre de paquets qui dépendent d'un paquet donnés, utilisez @command{guix refresh --list-dependent} (@pxref{Invoking guix refresh, @option{--list-dependent}})." #. type: item #: doc/guix.texi:7203 #, no-wrap msgid "bag-emerged" -msgstr "" +msgstr "bag-emerged" #. type: table #: doc/guix.texi:7205 msgid "This is the package DAG, @emph{including} implicit inputs." -msgstr "" +msgstr "C'est le DAG du paquet, @emph{avec} les entrées implicites." #. type: table #: doc/guix.texi:7207 msgid "For instance, the following command:" -msgstr "" +msgstr "Par exemple, la commande suivante :" #. type: example #: doc/guix.texi:7210 #, no-wrap msgid "guix graph --type=bag-emerged coreutils | dot -Tpdf > dag.pdf\n" -msgstr "" +msgstr "guix graph --type=bag-emerged coreutils | dot -Tpdf > dag.pdf\n" #. type: table #: doc/guix.texi:7213 msgid "... yields this bigger graph:" -msgstr "" +msgstr "… montre ce graphe plus gros :" #. type: table #: doc/guix.texi:7215 msgid "@image{images/coreutils-bag-graph,,5in,Detailed dependency graph of the GNU Coreutils}" -msgstr "" +msgstr "@image{images/coreutils-bag-graph,,5in,Graphe des dépendances détaillé de GNU Coreutils}" #. type: table #: doc/guix.texi:7218 msgid "At the bottom of the graph, we see all the implicit inputs of @var{gnu-build-system} (@pxref{Build Systems, @code{gnu-build-system}})." -msgstr "" +msgstr "En bas du graphe, on voit toutes les entrées implicites de @var{gnu-build-system} (@pxref{Build Systems, @code{gnu-build-system}})." #. type: table #: doc/guix.texi:7222 msgid "Now, note that the dependencies of these implicit inputs---that is, the @dfn{bootstrap dependencies} (@pxref{Bootstrapping})---are not shown here, for conciseness." -msgstr "" +msgstr "Maintenant, remarquez que les dépendances de ces entrées implicites — c'est-à-dire les @dfn{dépendances de bootstrap} (@pxref{Bootstrapping}) — ne sont pas affichées, pour rester concis." #. type: item #: doc/guix.texi:7223 #, no-wrap msgid "bag" -msgstr "" +msgstr "bag" #. type: table #: doc/guix.texi:7226 msgid "Similar to @code{bag-emerged}, but this time including all the bootstrap dependencies." -msgstr "" +msgstr "Comme @code{bag-emerged} mais cette fois inclus toutes les dépendances de bootstrap." #. type: item #: doc/guix.texi:7227 #, no-wrap msgid "bag-with-origins" -msgstr "" +msgstr "bag-with-origins" #. type: table #: doc/guix.texi:7229 msgid "Similar to @code{bag}, but also showing origins and their dependencies." -msgstr "" +msgstr "Comme @code{bag}, mais montre aussi les origines et leurs dépendances." #. type: table #: doc/guix.texi:7235 msgid "This is the most detailed representation: It shows the DAG of derivations (@pxref{Derivations}) and plain store items. Compared to the above representation, many additional nodes are visible, including build scripts, patches, Guile modules, etc." -msgstr "" +msgstr "C'est la représentation lu plus détaillée : elle montre le DAG des dérivations (@pxref{Derivations}) et des éléments du dépôt. Comparé à la représentation ci-dessus, beaucoup plus de nœuds sont visibles, dont les scripts de construction, les correctifs, les modules Guile, etc." #. type: table #: doc/guix.texi:7238 msgid "For this type of graph, it is also possible to pass a @file{.drv} file name instead of a package name, as in:" -msgstr "" +msgstr "Pour ce type de graphe, il est aussi possible de passer un nom de fichier @file{.drv} à la place d'un nom de paquet, comme dans :" #. type: example #: doc/guix.texi:7241 #, no-wrap msgid "guix graph -t derivation `guix system build -d my-config.scm`\n" -msgstr "" +msgstr "guix graph -t derivation `guix system build -d my-config.scm`\n" #. type: item #: doc/guix.texi:7243 @@ -13059,206 +13347,206 @@ msgstr "module" #. type: table #: doc/guix.texi:7247 msgid "This is the graph of @dfn{package modules} (@pxref{Package Modules}). For example, the following command shows the graph for the package module that defines the @code{guile} package:" -msgstr "" +msgstr "C'est le graphe des @dfn{modules de paquets} (@pxref{Package Modules}). Par exemple, la commande suivante montre le graphe des modules de paquets qui définissent le paquet @code{guile} :" #. type: example #: doc/guix.texi:7250 #, no-wrap msgid "guix graph -t module guile | dot -Tpdf > module-graph.pdf\n" -msgstr "" +msgstr "guix graph -t module guile | dot -Tpdf > module-graph.pdf\n" #. type: Plain text #: doc/guix.texi:7255 msgid "All the types above correspond to @emph{build-time dependencies}. The following graph type represents the @emph{run-time dependencies}:" -msgstr "" +msgstr "Tous les types ci-dessus correspondent aux @emph{dépendances à la construction}. Le type de graphe suivant représente les @emph{dépendances à l'exécution} :" #. type: item #: doc/guix.texi:7257 #, no-wrap msgid "references" -msgstr "" +msgstr "references" #. type: table #: doc/guix.texi:7260 msgid "This is the graph of @dfn{references} of a package output, as returned by @command{guix gc --references} (@pxref{Invoking guix gc})." -msgstr "" +msgstr "C'est le graphe des @dfn{references} d'une sortie d'un paquet, telles que renvoyées par @command{guix gc --references} (@pxref{Invoking guix gc})." #. type: table #: doc/guix.texi:7263 msgid "If the given package output is not available in the store, @command{guix graph} attempts to obtain dependency information from substitutes." -msgstr "" +msgstr "Si la sortie du paquet donnée n'est pas disponible dans le dépôt, @command{guix graph} essayera d'obtenir les informations sur les dépendances à travers les substituts." #. type: table #: doc/guix.texi:7267 msgid "Here you can also pass a store file name instead of a package name. For example, the command below produces the reference graph of your profile (which can be big!):" -msgstr "" +msgstr "Vous pouvez aussi passer un nom de fichier du dépôt plutôt qu'un nom de paquet. Par exemple, la commande ci-dessous produit le graphe des références de votre profile (qui peut être gros !) :" #. type: example #: doc/guix.texi:7270 #, no-wrap msgid "guix graph -t references `readlink -f ~/.guix-profile`\n" -msgstr "" +msgstr "guix graph -t references `readlink -f ~/.guix-profile`\n" #. type: item #: doc/guix.texi:7272 #, no-wrap msgid "referrers" -msgstr "" +msgstr "referrers" #. type: table #: doc/guix.texi:7275 msgid "This is the graph of the @dfn{referrers} of a store item, as returned by @command{guix gc --referrers} (@pxref{Invoking guix gc})." -msgstr "" +msgstr "C'est le graphe des @dfn{référents} d'un élément du dépôt, tels que renvoyés par @command{guix gc --referrers} (@pxref{Invoking guix gc})." #. type: table #: doc/guix.texi:7281 msgid "This relies exclusively on local information from your store. For instance, let us suppose that the current Inkscape is available in 10 profiles on your machine; @command{guix graph -t referrers inkscape} will show a graph rooted at Inkscape and with those 10 profiles linked to it." -msgstr "" +msgstr "Cela repose exclusivement sur les informations de votre dépôt. Par exemple, supposons que Inkscape est actuellement disponible dans 10 profils sur votre machine ; @command{guix graph -t referrers inkscape} montrera le graphe dont la racine est Inkscape avec 10 profils qui y sont liés." #. type: table #: doc/guix.texi:7284 msgid "It can help determine what is preventing a store item from being garbage collected." -msgstr "" +msgstr "Cela peut aider à déterminer ce qui empêche un élément du dépôt d'être glané." #. type: Plain text #: doc/guix.texi:7288 msgid "The available options are the following:" -msgstr "" +msgstr "Les options disponibles sont les suivante :" #. type: item #: doc/guix.texi:7290 #, no-wrap msgid "--type=@var{type}" -msgstr "" +msgstr "--type=@var{type}" #. type: itemx #: doc/guix.texi:7291 doc/guix.texi:21087 #, no-wrap msgid "-t @var{type}" -msgstr "" +msgstr "-t @var{type}" #. type: table #: doc/guix.texi:7294 msgid "Produce a graph output of @var{type}, where @var{type} must be one of the values listed above." -msgstr "" +msgstr "Produit un graphe en sortie de type @var{type} où @var{type} doit être l'un des types au-dessus." #. type: item #: doc/guix.texi:7295 #, no-wrap msgid "--list-types" -msgstr "" +msgstr "--list-types" #. type: table #: doc/guix.texi:7297 msgid "List the supported graph types." -msgstr "" +msgstr "Liste les types de graphes supportés." #. type: item #: doc/guix.texi:7298 #, no-wrap msgid "--backend=@var{backend}" -msgstr "" +msgstr "--backend=@var{moteur}" #. type: itemx #: doc/guix.texi:7299 #, no-wrap msgid "-b @var{backend}" -msgstr "" +msgstr "-b @var{moteur}" #. type: table #: doc/guix.texi:7301 msgid "Produce a graph using the selected @var{backend}." -msgstr "" +msgstr "Produit un graphe avec le @var{moteur} choisi." #. type: item #: doc/guix.texi:7302 #, no-wrap msgid "--list-backends" -msgstr "" +msgstr "--list-backends" #. type: table #: doc/guix.texi:7304 msgid "List the supported graph backends." -msgstr "" +msgstr "Liste les moteurs de graphes supportés." #. type: table #: doc/guix.texi:7306 msgid "Currently, the available backends are Graphviz and d3.js." -msgstr "" +msgstr "Actuellement les moteurs disponibles sont Graphviz et d3.js." #. type: example #: doc/guix.texi:7315 #, no-wrap msgid "guix graph -e '(@@@@ (gnu packages commencement) gnu-make-final)'\n" -msgstr "" +msgstr "guix graph -e '(@@@@ (gnu packages commencement) gnu-make-final)'\n" #. type: section #: doc/guix.texi:7320 #, no-wrap msgid "Invoking @command{guix environment}" -msgstr "" +msgstr "Invoquer @command{guix environment}" #. type: cindex #: doc/guix.texi:7322 #, no-wrap msgid "reproducible build environments" -msgstr "" +msgstr "environnements de construction reproductibles" #. type: cindex #: doc/guix.texi:7323 #, no-wrap msgid "development environments" -msgstr "" +msgstr "environnement de développement" #. type: command{#1} #: doc/guix.texi:7324 #, no-wrap msgid "guix environment" -msgstr "" +msgstr "guix environment" #. type: cindex #: doc/guix.texi:7325 #, no-wrap msgid "environment, package build environment" -msgstr "" +msgstr "environnement de construction de paquets" #. type: Plain text #: doc/guix.texi:7331 msgid "The purpose of @command{guix environment} is to assist hackers in creating reproducible development environments without polluting their package profile. The @command{guix environment} tool takes one or more packages, builds all of their inputs, and creates a shell environment to use them." -msgstr "" +msgstr "Le but de @command{guix environment} est d'assister les hackers dans la création d'environnements de développement reproductibles sans polluer leur profil de paquets. L'outil @command{guix environment} prend un ou plusieurs paquets, construit leurs entrées et crée un environnement shell pour pouvoir les utiliser." #. type: example #: doc/guix.texi:7336 #, no-wrap msgid "guix environment @var{options} @var{package}@dots{}\n" -msgstr "" +msgstr "guix environment @var{options} @var{paquet}@dots{}\n" #. type: Plain text #: doc/guix.texi:7340 msgid "The following example spawns a new shell set up for the development of GNU@tie{}Guile:" -msgstr "" +msgstr "L'exemple suivant crée un nouveau shell préparé pour le développement de GNU@tie{}Guile :" #. type: example #: doc/guix.texi:7343 #, no-wrap msgid "guix environment guile\n" -msgstr "" +msgstr "guix environment guile\n" #. type: Plain text #: doc/guix.texi:7360 msgid "If the needed dependencies are not built yet, @command{guix environment} automatically builds them. The environment of the new shell is an augmented version of the environment that @command{guix environment} was run in. It contains the necessary search paths for building the given package added to the existing environment variables. To create a ``pure'' environment, in which the original environment variables have been unset, use the @code{--pure} option@footnote{Users sometimes wrongfully augment environment variables such as @code{PATH} in their @file{~/.bashrc} file. As a consequence, when @code{guix environment} launches it, Bash may read @file{~/.bashrc}, thereby introducing ``impurities'' in these environment variables. It is an error to define such environment variables in @file{.bashrc}; instead, they should be defined in @file{.bash_profile}, which is sourced only by log-in shells. @xref{Bash Startup Files,,, bash, The GNU Bash Reference Manual}, for details on Bash start-up files.}." -msgstr "" +msgstr "Si les dépendances requises ne sont pas déjà construites, @command{guix environment} les construit automatiquement. L'environnement du nouveau shell est une version améliorée de l'environnement dans lequel @command{guix environment} a été lancé. Il contient les chemins de recherche nécessaires à la construction du paquet donné en plus des variables d'environnement existantes. Pour créer un environnement « pur », dans lequel les variables d'environnement de départ ont été nettoyées, utilisez l'option @code{--pure}@footnote{Les utilisateurs ajoutent parfois à tord des valeurs supplémentaires dans les variables comme @code{PATH} dans leur @file{~/.bashrc}. En conséquence, lorsque @code{guix environment} le lance, Bash peut lire @file{~/.bashrc}, ce qui produit des « impuretés » dans ces variables d'environnement. C'est une erreur de définir ces variables d'environnement dans @file{.bashrc} ; à la place, elles devraient être définie dans @file{.bash_profile}, qui est sourcé uniquement par les shells de connexion. @xref{Bash Startup Files,,, bash, The GNU Bash Reference Manual}, pour des détails sur les fichiers de démarrage de Bash.}." #. type: vindex #: doc/guix.texi:7361 #, no-wrap msgid "GUIX_ENVIRONMENT" -msgstr "" +msgstr "GUIX_ENVIRONMENT" #. type: Plain text #: doc/guix.texi:7367 msgid "@command{guix environment} defines the @code{GUIX_ENVIRONMENT} variable in the shell it spawns; its value is the file name of the profile of this environment. This allows users to, say, define a specific prompt for development environments in their @file{.bashrc} (@pxref{Bash Startup Files,,, bash, The GNU Bash Reference Manual}):" -msgstr "" +msgstr "@command{guix environment} définie la variable @code{GUIX_ENVIRONMENT} dans le shell qu'il crée ; sa valeur est le nom de fichier du profil de cet environnement. Cela permet aux utilisateur, disons, de définir un prompt spécifique pour les environnement de développement dans leur @file{.bashrc} (@pxref{Bash Startup Files,,, bash, The GNU Bash Reference Manual}) :" #. type: example #: doc/guix.texi:7373 @@ -13269,338 +13557,342 @@ msgid "" " export PS1=\"\\u@@\\h \\w [dev]\\$ \"\n" "fi\n" msgstr "" +"if [ -n \"$GUIX_ENVIRONMENT\" ]\n" +"then\n" +" export PS1=\"\\u@@\\h \\w [dev]\\$ \"\n" +"fi\n" #. type: Plain text #: doc/guix.texi:7377 msgid "... or to browse the profile:" -msgstr "" +msgstr "… ou de naviguer dans le profil :" #. type: example #: doc/guix.texi:7380 #, no-wrap msgid "$ ls \"$GUIX_ENVIRONMENT/bin\"\n" -msgstr "" +msgstr "$ ls \"$GUIX_ENVIRONMENT/bin\"\n" #. type: Plain text #: doc/guix.texi:7386 msgid "Additionally, more than one package may be specified, in which case the union of the inputs for the given packages are used. For example, the command below spawns a shell where all of the dependencies of both Guile and Emacs are available:" -msgstr "" +msgstr "En plus, plus d'un paquet peut être spécifié, auquel cas l'union des entrées des paquets données est utilisée. Par exemple, la commande ci-dessous crée un shell où toutes les dépendances de Guile et Emacs sont disponibles :" #. type: example #: doc/guix.texi:7389 #, no-wrap msgid "guix environment guile emacs\n" -msgstr "" +msgstr "guix environment guile emacs\n" #. type: Plain text #: doc/guix.texi:7394 msgid "Sometimes an interactive shell session is not desired. An arbitrary command may be invoked by placing the @code{--} token to separate the command from the rest of the arguments:" -msgstr "" +msgstr "Parfois, une session shell interactive est inutile. On peut invoquer une commande arbitraire en plaçant le jeton @code{--} pour séparer la commande du reste des arguments :" #. type: example #: doc/guix.texi:7397 #, no-wrap msgid "guix environment guile -- make -j4\n" -msgstr "" +msgstr "guix environment guile -- make -j4\n" #. type: Plain text #: doc/guix.texi:7403 msgid "In other situations, it is more convenient to specify the list of packages needed in the environment. For example, the following command runs @command{python} from an environment containing Python@tie{}2.7 and NumPy:" -msgstr "" +msgstr "Dans d'autres situations, il est plus pratique de spécifier la liste des paquets requis dans l'environnement. Par exemple, la commande suivante lance @command{python} dans un environnement contenant Python@tie{}2.7 et NumPy :" #. type: example #: doc/guix.texi:7406 #, no-wrap msgid "guix environment --ad-hoc python2-numpy python-2.7 -- python\n" -msgstr "" +msgstr "guix environment --ad-hoc python2-numpy python-2.7 -- python\n" #. type: Plain text #: doc/guix.texi:7417 msgid "Furthermore, one might want the dependencies of a package and also some additional packages that are not build-time or runtime dependencies, but are useful when developing nonetheless. Because of this, the @code{--ad-hoc} flag is positional. Packages appearing before @code{--ad-hoc} are interpreted as packages whose dependencies will be added to the environment. Packages appearing after are interpreted as packages that will be added to the environment directly. For example, the following command creates a Guix development environment that additionally includes Git and strace:" -msgstr "" +msgstr "En plus, on peut vouloir les dépendance d'un paquet et aussi des paquets supplémentaires qui ne sont pas des dépendances à l'exécution ou à la construction, mais qui sont utiles au développement tout de même. À cause de cela, le drapeau @code{--ad-hoc} est positionnel. Les paquets qui apparaissent avant @code{--ad-hoc} sont interprétés comme les paquets dont les dépendances seront ajoutées à l'environnement. Les paquets qui apparaissent après @code{--ad-hoc} sont interprétés comme les paquets à ajouter à l'environnement directement. Par exemple, la commande suivante crée un environnement de développement pour Guix avec les paquets Git et strace en plus :" #. type: example #: doc/guix.texi:7420 #, no-wrap msgid "guix environment guix --ad-hoc git strace\n" -msgstr "" +msgstr "guix environment guix --ad-hoc git strace\n" #. type: Plain text #: doc/guix.texi:7429 msgid "Sometimes it is desirable to isolate the environment as much as possible, for maximal purity and reproducibility. In particular, when using Guix on a host distro that is not GuixSD, it is desirable to prevent access to @file{/usr/bin} and other system-wide resources from the development environment. For example, the following command spawns a Guile REPL in a ``container'' where only the store and the current working directory are mounted:" -msgstr "" +msgstr "Parfois il est souhaitable d'isoler l'environnement le plus possible, pour une pureté et une reproductibilité maximale. En particulier, lorsque vous utilisez Guix sur une distribution hôte qui n'est pas GuixSD, il est souhaitable d'éviter l'accès à @file{/usr/bin} et d'autres ressources du système depuis les environnements de développement. Par exemple, la commande suivante crée un REPL Guile dans un « conteneur » où seuls le dépôt et le répertoire de travail actuel sont montés :" #. type: example #: doc/guix.texi:7432 #, no-wrap msgid "guix environment --ad-hoc --container guile -- guile\n" -msgstr "" +msgstr "guix environment --ad-hoc --container guile -- guile\n" #. type: quotation #: doc/guix.texi:7436 msgid "The @code{--container} option requires Linux-libre 3.19 or newer." -msgstr "" +msgstr "L'option @code{--container} requiert Linux-libre 3.19 ou supérieur." #. type: Plain text #: doc/guix.texi:7439 msgid "The available options are summarized below." -msgstr "" +msgstr "Les options disponibles sont résumées ci-dessous." #. type: cindex #: doc/guix.texi:7443 #, no-wrap msgid "persistent environment" -msgstr "" +msgstr "environnement persistent" #. type: cindex #: doc/guix.texi:7444 #, no-wrap msgid "garbage collector root, for environments" -msgstr "" +msgstr "racine du ramasse-miettes, pour les environnements" #. type: table #: doc/guix.texi:7447 msgid "Make @var{file} a symlink to the profile for this environment, and register it as a garbage collector root." -msgstr "" +msgstr "Fait de @var{fichier} un lien symbolique vers le profil de cet environnement, et l'enregistre comme une racine du ramasse-miettes." #. type: table #: doc/guix.texi:7450 msgid "This is useful if you want to protect your environment from garbage collection, to make it ``persistent''." -msgstr "" +msgstr "C'est utile si vous souhaitez protéger votre environnement du ramasse-miettes, pour le rendre « persistent »." #. type: table #: doc/guix.texi:7456 msgid "When this option is omitted, the environment is protected from garbage collection only for the duration of the @command{guix environment} session. This means that next time you recreate the same environment, you could have to rebuild or re-download packages. @xref{Invoking guix gc}, for more on GC roots." -msgstr "" +msgstr "Lorsque cette option est omise, l'environnement n'est protégé du ramasse-miettes que le temps de la session @command{guix environment}. Cela signifie que la prochaine fois que vous créerez le même environnement, vous pourriez avoir à reconstruire ou télécharger des paquets. @xref{Invoking guix gc}, pour plus d'informations sur les racines du GC." #. type: table #: doc/guix.texi:7461 msgid "Create an environment for the package or list of packages that @var{expr} evaluates to." -msgstr "" +msgstr "Crée un environnement pour le paquet ou la liste de paquets en lesquels s'évalue @var{expr}." #. type: table #: doc/guix.texi:7463 msgid "For example, running:" -msgstr "" +msgstr "Par exemple, lancer :" #. type: example #: doc/guix.texi:7466 #, no-wrap msgid "guix environment -e '(@@ (gnu packages maths) petsc-openmpi)'\n" -msgstr "" +msgstr "guix environment -e '(@@ (gnu packages maths) petsc-openmpi)'\n" #. type: table #: doc/guix.texi:7470 msgid "starts a shell with the environment for this specific variant of the PETSc package." -msgstr "" +msgstr "démarre un shell avec l'environnement pour cette variante spécifique du paquet PETSc." #. type: table #: doc/guix.texi:7472 msgid "Running:" -msgstr "" +msgstr "Lancer :" #. type: example #: doc/guix.texi:7475 #, no-wrap msgid "guix environment --ad-hoc -e '(@@ (gnu) %base-packages)'\n" -msgstr "" +msgstr "guix environment --ad-hoc -e '(@@ (gnu) %base-packages)'\n" #. type: table #: doc/guix.texi:7478 msgid "starts a shell with all the GuixSD base packages available." -msgstr "" +msgstr "démarre un shell où tous les paquets de base de GuixSD sont disponibles." #. type: table #: doc/guix.texi:7481 msgid "The above commands only use the default output of the given packages. To select other outputs, two element tuples can be specified:" -msgstr "" +msgstr "Les commande au-dessus n'utilisent que les sorties par défaut des paquets donnés. Pour choisir d'autres sorties, on peut spécifier des pairs :" #. type: example #: doc/guix.texi:7484 #, no-wrap msgid "guix environment --ad-hoc -e '(list (@@ (gnu packages bash) bash) \"include\")'\n" -msgstr "" +msgstr "guix environment --ad-hoc -e '(list (@@ (gnu packages bash) bash) \"include\")'\n" #. type: item #: doc/guix.texi:7486 #, no-wrap msgid "--load=@var{file}" -msgstr "" +msgstr "--load=@var{fichier}" #. type: itemx #: doc/guix.texi:7487 #, no-wrap msgid "-l @var{file}" -msgstr "" +msgstr "-l @var{fichier}" #. type: table #: doc/guix.texi:7490 msgid "Create an environment for the package or list of packages that the code within @var{file} evaluates to." -msgstr "" +msgstr "Crée un environnement pour le paquet ou la liste de paquets en lesquels @var{fichier} s'évalue." #. type: example #: doc/guix.texi:7496 #, no-wrap msgid "@verbatiminclude environment-gdb.scm\n" -msgstr "" +msgstr "@verbatiminclude environment-gdb.scm\n" #. type: table #: doc/guix.texi:7502 msgid "Create an environment for the packages contained in the manifest object returned by the Scheme code in @var{file}." -msgstr "" +msgstr "Crée un environnement pour les paquets contenus dans l'objet manifeste renvoyé par le code Scheme dans @var{fichier}." #. type: table #: doc/guix.texi:7506 msgid "This is similar to the same-named option in @command{guix package} (@pxref{profile-manifest, @option{--manifest}}) and uses the same manifest files." -msgstr "" +msgstr "C'est similaire à l'option de même nom de @command{guix package} (@pxref{profile-manifest, @option{--manifest}}) et utilise les même fichiers manifestes." #. type: item #: doc/guix.texi:7507 #, no-wrap msgid "--ad-hoc" -msgstr "" +msgstr "--ad-hoc" #. type: table #: doc/guix.texi:7512 msgid "Include all specified packages in the resulting environment, as if an @i{ad hoc} package were defined with them as inputs. This option is useful for quickly creating an environment without having to write a package expression to contain the desired inputs." -msgstr "" +msgstr "Inclut tous les paquets spécifiés dans l'environnement qui en résulte, comme si un paquet @i{ad hoc} était spécifié, avec ces paquets comme entrées. Cette option est utile pour créer un environnement rapidement sans avoir à écrire une expression de paquet contenant les entrées désirées." #. type: table #: doc/guix.texi:7514 msgid "For instance, the command:" -msgstr "" +msgstr "Par exemple la commande :" #. type: example #: doc/guix.texi:7517 #, no-wrap msgid "guix environment --ad-hoc guile guile-sdl -- guile\n" -msgstr "" +msgstr "guix environment --ad-hoc guile guile-sdl -- guile\n" #. type: table #: doc/guix.texi:7521 msgid "runs @command{guile} in an environment where Guile and Guile-SDL are available." -msgstr "" +msgstr "lance @command{guile} dans un environnement où Guile et Guile-SDDL sont disponibles." #. type: table #: doc/guix.texi:7526 msgid "Note that this example implicitly asks for the default output of @code{guile} and @code{guile-sdl}, but it is possible to ask for a specific output---e.g., @code{glib:bin} asks for the @code{bin} output of @code{glib} (@pxref{Packages with Multiple Outputs})." -msgstr "" +msgstr "Remarquez que cet exemple demande implicitement la sortie par défaut de @code{guile} et @code{guile-sdl}, mais il est possible de demander une sortie spécifique — p.@: ex.@: @code{glib:bin} demande la sortie @code{bin} de @code{glib} (@pxref{Packages with Multiple Outputs})." #. type: table #: doc/guix.texi:7532 msgid "This option may be composed with the default behavior of @command{guix environment}. Packages appearing before @code{--ad-hoc} are interpreted as packages whose dependencies will be added to the environment, the default behavior. Packages appearing after are interpreted as packages that will be added to the environment directly." -msgstr "" +msgstr "Cette option peut être composée avec le comportement par défaut de @command{guix environment}. Les paquets qui apparaissent avant @code{--ad-hoc} sont interprétés comme les paquets dont les dépendances seront ajoutées à l'environnement, le comportement par défaut. Les paquets qui apparaissent après @code{--ad-hoc} sont interprétés comme les paquets à ajouter à l'environnement directement." #. type: item #: doc/guix.texi:7533 #, no-wrap msgid "--pure" -msgstr "" +msgstr "--pure" #. type: table #: doc/guix.texi:7537 msgid "Unset existing environment variables when building the new environment. This has the effect of creating an environment in which search paths only contain package inputs." -msgstr "" +msgstr "Nettoie les variables d'environnement existantes lors de la construction du nouvel environnement. Cela a pour effet de créer un environnement dans lequel les chemins de recherche ne contiennent que des entrées de paquets." #. type: item #: doc/guix.texi:7538 #, no-wrap msgid "--search-paths" -msgstr "" +msgstr "--search-paths" #. type: table #: doc/guix.texi:7541 msgid "Display the environment variable definitions that make up the environment." -msgstr "" +msgstr "Affiche les définitions des variables d'environnement qui composent l'environnement." #. type: table #: doc/guix.texi:7545 msgid "Attempt to build for @var{system}---e.g., @code{i686-linux}." -msgstr "" +msgstr "Essaye de construire pour @var{système} — p.@: ex.@: @code{i686-linux}." #. type: item #: doc/guix.texi:7546 #, no-wrap msgid "--container" -msgstr "" +msgstr "--container" #. type: itemx #: doc/guix.texi:7547 #, no-wrap msgid "-C" -msgstr "" +msgstr "-C" #. type: item #: doc/guix.texi:7548 doc/guix.texi:8059 doc/guix.texi:21036 #, no-wrap msgid "container" -msgstr "" +msgstr "conteneur" #. type: table #: doc/guix.texi:7556 msgid "Run @var{command} within an isolated container. The current working directory outside the container is mapped inside the container. Additionally, unless overridden with @code{--user}, a dummy home directory is created that matches the current user's home directory, and @file{/etc/passwd} is configured accordingly. The spawned process runs as the current user outside the container, but has root privileges in the context of the container." -msgstr "" +msgstr "Lance @var{commande} dans un conteneur isolé. Le répertoire de travail actuel en dehors du conteneur est monté dans le conteneur. En plus, à moins de le changer avec @code{--user}, un répertoire personnel fictif est créé pour correspondre à celui de l'utilisateur actuel et @file{/etc/passwod} est configuré en conséquence. Le processus est lancé en tant que l'utilisateur actuel en dehors du conteneur, mais a les privilèges root dans le contexte du conteneur." #. type: item #: doc/guix.texi:7557 #, no-wrap msgid "--network" -msgstr "" +msgstr "--network" #. type: itemx #: doc/guix.texi:7558 #, no-wrap msgid "-N" -msgstr "" +msgstr "-N" #. type: table #: doc/guix.texi:7562 msgid "For containers, share the network namespace with the host system. Containers created without this flag only have access to the loopback device." -msgstr "" +msgstr "Pour les conteneurs, partage l'espace de nom du réseau avec le système hôte. Les conteneurs créés sans cette option n'ont accès qu'à l'interface de boucle locale." #. type: item #: doc/guix.texi:7563 #, no-wrap msgid "--link-profile" -msgstr "" +msgstr "--link-profile" #. type: itemx #: doc/guix.texi:7564 #, no-wrap msgid "-P" -msgstr "" +msgstr "-P" #. type: table #: doc/guix.texi:7571 msgid "For containers, link the environment profile to @file{~/.guix-profile} within the container. This is equivalent to running the command @command{ln -s $GUIX_ENVIRONMENT ~/.guix-profile} within the container. Linking will fail and abort the environment if the directory already exists, which will certainly be the case if @command{guix environment} was invoked in the user's home directory." -msgstr "" +msgstr "Pour les conteneurs, lie le profil de l'environnement à @file{~/.guix-profile} dans le conteneur. C'est équivalent à lance la commande @command{ln -s $GUIX_ENVIRONMENT ~/.guix-profile} dans le conteneur. La liaison échouera et annulera l'environnement si le répertoire existe déjà, ce qui sera sans doute le cas si @command{guix environment} est invoqué dans le répertoire personnel de l'utilisateur." #. type: table #: doc/guix.texi:7578 msgid "Certain packages are configured to look in @code{~/.guix-profile} for configuration files and data;@footnote{For example, the @code{fontconfig} package inspects @file{~/.guix-profile/share/fonts} for additional fonts.} @code{--link-profile} allows these programs to behave as expected within the environment." -msgstr "" +msgstr "Certains paquets sont configurés pour chercher des fichiers de configuration et des données dans @code{~/.guix-profile}@footnote{Par exemple, le paquet @code{fontconfig} inspecte @file{~/.guix-profile/share/fonts} pour trouver des polices supplémentaires.} ; @code{--link-profile} permet à ces programmes de se comporter comme attendu dans l'environnement." #. type: item #: doc/guix.texi:7579 doc/guix.texi:7731 #, no-wrap msgid "--user=@var{user}" -msgstr "" +msgstr "--user=@var{utilisateur}" #. type: itemx #: doc/guix.texi:7580 doc/guix.texi:7732 #, no-wrap msgid "-u @var{user}" -msgstr "" +msgstr "-u @var{utilisateur}" #. type: table #: doc/guix.texi:7586 msgid "For containers, use the username @var{user} in place of the current user. The generated @file{/etc/passwd} entry within the container will contain the name @var{user}; the home directory will be @file{/home/USER}; and no user GECOS data will be copied. @var{user} need not exist on the system." -msgstr "" +msgstr "Pour les conteneurs, utilise le nom d'utilisateur @var{utilisateur} à la place de l'utilisateur actuel. L'entrée générée dans @file{/etc/passwod} dans le conteneur contiendra le nom @var{utilisateur} ; le répertoire personnel sera @file{/home/UTILISATEUR} ; et aucune donnée GECOS ne sera copiée. @var{utilisateur} n'a pas besoin d'exister sur le système." #. type: table #: doc/guix.texi:7591 msgid "Additionally, any shared or exposed path (see @code{--share} and @code{--expose} respectively) whose target is within the current user's home directory will be remapped relative to @file{/home/USER}; this includes the automatic mapping of the current working directory." -msgstr "" +msgstr "En plus, tous les chemins partagés ou exposés (voir @code{--share} et @code{--expose} respectivement) dont la cible est dans le répertoire personnel de l'utilisateur seront remontés relativement à @file{/home/UTILISATEUR} ; cela comprend le montage automatique du répertoire de travail actuel." #. type: example #: doc/guix.texi:7598 @@ -13612,72 +13904,77 @@ msgid "" " --expose=$HOME/test \\\n" " --expose=/tmp/target=$HOME/target\n" msgstr "" +"# exposera les chemins comme /home/foo/wd, /home/foo/test et /home/foo/target\n" +"cd $HOME/wd\n" +"guix environment --container --user=foo \\\n" +" --expose=$HOME/test \\\n" +" --expose=/tmp/target=$HOME/target\n" #. type: table #: doc/guix.texi:7603 msgid "While this will limit the leaking of user identity through home paths and each of the user fields, this is only one useful component of a broader privacy/anonymity solution---not one in and of itself." -msgstr "" +msgstr "Bien que cela limite la fuite de l'identité de l'utilisateur à travers le chemin du répertoire personnel et des champs de l'utilisateur, ce n'est qu'un composant utile pour une solution d'anonymisation ou de préservation de la vie privée — pas une solution en elle-même." #. type: item #: doc/guix.texi:7604 #, no-wrap msgid "--expose=@var{source}[=@var{target}]" -msgstr "" +msgstr "--expose=@var{source}[=@var{cible}]" #. type: table #: doc/guix.texi:7609 msgid "For containers, expose the file system @var{source} from the host system as the read-only file system @var{target} within the container. If @var{target} is not specified, @var{source} is used as the target mount point in the container." -msgstr "" +msgstr "Pour les conteneurs, expose le système de fichiers @var{source} du système hôte comme un système de fichiers en lecture seule @var{cible} dans le conteneur. Si @var{cible} n'est pas spécifiée, @var{source} est utilisé comme point de montage dans le conteneur." #. type: table #: doc/guix.texi:7613 msgid "The example below spawns a Guile REPL in a container in which the user's home directory is accessible read-only via the @file{/exchange} directory:" -msgstr "" +msgstr "L'exemple ci-dessous crée un REPL Guile dans un conteneur dans lequel le répertoire personnel de l'utilisateur est accessible en lecture-seule via le répertoire @file{/exchange} :" #. type: example #: doc/guix.texi:7616 #, no-wrap msgid "guix environment --container --expose=$HOME=/exchange --ad-hoc guile -- guile\n" -msgstr "" +msgstr "guix environment --container --expose=$HOME=/exchange --ad-hoc guile -- guile\n" #. type: item #: doc/guix.texi:7618 #, no-wrap msgid "--share=@var{source}[=@var{target}]" -msgstr "" +msgstr "--share=@var{source}[=@var{cible}]" #. type: table #: doc/guix.texi:7623 msgid "For containers, share the file system @var{source} from the host system as the writable file system @var{target} within the container. If @var{target} is not specified, @var{source} is used as the target mount point in the container." -msgstr "" +msgstr "Pour les conteneurs, partage le système de fichiers @var{soruce} du système hôte comme un système de fichiers en lecture-écriture @var{cible} dans le conteneur. Si @var{cible} n'est pas spécifiée, @var{source} est utilisée comme point de montage dans le conteneur." #. type: table #: doc/guix.texi:7627 msgid "The example below spawns a Guile REPL in a container in which the user's home directory is accessible for both reading and writing via the @file{/exchange} directory:" -msgstr "" +msgstr "L'exemple ci-dessous crée un REPL Guile dans un conteneur dans lequel le répertoire personnel de l'utilisateur est accessible en lecture-écriture via le répertoire @file{/exchange} :" #. type: example #: doc/guix.texi:7630 #, no-wrap msgid "guix environment --container --share=$HOME=/exchange --ad-hoc guile -- guile\n" -msgstr "" +msgstr "guix environment --container --share=$HOME=/exchange --ad-hoc guile -- guile\n" #. type: Plain text #: doc/guix.texi:7636 msgid "@command{guix environment} also supports all of the common build options that @command{guix build} supports (@pxref{Common Build Options})." -msgstr "" +msgstr "@command{guix environment} supporte aussi toutes les options de construction que @command{guix build} supporte (@pxref{Common Build Options})." #. type: section #: doc/guix.texi:7639 #, no-wrap msgid "Invoking @command{guix publish}" -msgstr "" +msgstr "Invoquer @command{guix publish}" #. type: command{#1} #: doc/guix.texi:7641 #, no-wrap msgid "guix publish" -msgstr "" +msgstr "guix publish" #. type: Plain text #: doc/guix.texi:7645 @@ -13687,7 +13984,7 @@ msgstr "Le but de @command{guix publish} est de vous permettre de partager facil #. type: Plain text #: doc/guix.texi:7651 msgid "When @command{guix publish} runs, it spawns an HTTP server which allows anyone with network access to obtain substitutes from it. This means that any machine running Guix can also act as if it were a build farm, since the HTTP interface is compatible with Hydra, the software behind the @code{hydra.gnu.org} build farm." -msgstr "" +msgstr "Lorsque @command{guix publish} est lancé, il crée un serveur HTTP qui permet à n'importe qui avec un accès réseau d'y récupérer des substituts. Cela signifie que toutes les machines qui font tourner Guix peuvent aussi agir comme une ferme de construction, puisque l'interface HTTP est compatible avec Hydra, le logiciel derrière la ferme de construction @code{hydra.gnu.org}." #. type: Plain text #: doc/guix.texi:7657 @@ -13697,272 +13994,272 @@ msgstr "Pour des raisons de sécurité, chaque substitut est signé, ce qui perm #. type: Plain text #: doc/guix.texi:7661 msgid "The signing key pair must be generated before @command{guix publish} is launched, using @command{guix archive --generate-key} (@pxref{Invoking guix archive})." -msgstr "" +msgstr "La pair de clefs pour les signatures doit être générée avant de lancer @command{guix publish}, avec @command{guix archive --generate-key} (@pxref{Invoking guix archive})." #. type: example #: doc/guix.texi:7666 #, no-wrap msgid "guix publish @var{options}@dots{}\n" -msgstr "" +msgstr "guix publish @var{options}@dots{}\n" #. type: Plain text #: doc/guix.texi:7670 msgid "Running @command{guix publish} without any additional arguments will spawn an HTTP server on port 8080:" -msgstr "" +msgstr "Lancer @command{guix publish} sans arguments supplémentaires lancera un serveur HTTP sur le port 8080 :" #. type: example #: doc/guix.texi:7673 #, no-wrap msgid "guix publish\n" -msgstr "" +msgstr "guix publish\n" #. type: Plain text #: doc/guix.texi:7677 msgid "Once a publishing server has been authorized (@pxref{Invoking guix archive}), the daemon may download substitutes from it:" -msgstr "" +msgstr "Une fois qu'un serveur de publication a été autorisé (@pxref{Invoking guix archive}), le démon peut télécharger des substituts à partir de lui :" #. type: example #: doc/guix.texi:7680 #, no-wrap msgid "guix-daemon --substitute-urls=http://example.org:8080\n" -msgstr "" +msgstr "guix-daemon --substitute-urls=http://example.org:8080\n" #. type: Plain text #: doc/guix.texi:7689 msgid "By default, @command{guix publish} compresses archives on the fly as it serves them. This ``on-the-fly'' mode is convenient in that it requires no setup and is immediately available. However, when serving lots of clients, we recommend using the @option{--cache} option, which enables caching of the archives before they are sent to clients---see below for details. The @command{guix weather} command provides a handy way to check what a server provides (@pxref{Invoking guix weather})." -msgstr "" +msgstr "Par défaut, @command{guix publish} compresse les archives à la volée quand il les sert. Ce mode « à la volée » est pratique puisqu'il ne demande aucune configuration et est disponible immédiatement. Cependant, lorsqu'il s'agit de servir beaucoup de clients, nous recommandons d'utiliser l'option @option{--cache}, qui active le cache des archives avant de les envoyer aux clients — voir les détails plus bas. La commande @command{guix weather} fournit un manière pratique de vérifier ce qu'un serveur fournit (@pxref{Invoking guix weather})." #. type: Plain text #: doc/guix.texi:7696 msgid "As a bonus, @command{guix publish} also serves as a content-addressed mirror for source files referenced in @code{origin} records (@pxref{origin Reference}). For instance, assuming @command{guix publish} is running on @code{example.org}, the following URL returns the raw @file{hello-2.10.tar.gz} file with the given SHA256 hash (represented in @code{nix-base32} format, @pxref{Invoking guix hash}):" -msgstr "" +msgstr "En bonus, @command{guix publish} sert aussi un miroir adressé par le contenu des fichiers source référencées dans les enregistrements @code{origin} (@pxref{origin Reference}). Par exemple, en supposant que @command{guix publish} tourne sur @code{example.org}, l'URL suivante renverra le fichie brut @file{hello-2.10.tar.gz} avec le hash SHA256 donné (représenté sous le format @code{nix-base32}, @pxref{Invoking guix hash}) :" #. type: example #: doc/guix.texi:7699 #, no-wrap msgid "http://example.org/file/hello-2.10.tar.gz/sha256/0ssi1@dots{}ndq1i\n" -msgstr "" +msgstr "http://example.org/file/hello-2.10.tar.gz/sha256/0ssi1@dots{}ndq1i\n" #. type: Plain text #: doc/guix.texi:7703 msgid "Obviously, these URLs only work for files that are in the store; in other cases, they return 404 (``Not Found'')." -msgstr "" +msgstr "Évidemment, ces URL ne fonctionnent que pour des fichiers dans le dépôt ; dans les autres cas, elles renvoie une erreur 404 (« Introuvable »)." #. type: cindex #: doc/guix.texi:7704 #, no-wrap msgid "build logs, publication" -msgstr "" +msgstr "journaux de construction, publication" #. type: Plain text #: doc/guix.texi:7706 msgid "Build logs are available from @code{/log} URLs like:" -msgstr "" +msgstr "Les journaux de construction sont disponibles à partir des URL @code{/log} comme ceci :" #. type: example #: doc/guix.texi:7709 #, no-wrap msgid "http://example.org/log/gwspk@dots{}-guile-2.2.3\n" -msgstr "" +msgstr "http://example.org/log/gwspk@dots{}-guile-2.2.3\n" #. type: Plain text #: doc/guix.texi:7719 msgid "When @command{guix-daemon} is configured to save compressed build logs, as is the case by default (@pxref{Invoking guix-daemon}), @code{/log} URLs return the compressed log as-is, with an appropriate @code{Content-Type} and/or @code{Content-Encoding} header. We recommend running @command{guix-daemon} with @code{--log-compression=gzip} since Web browsers can automatically decompress it, which is not the case with bzip2 compression." -msgstr "" +msgstr "Lorsque @command{guix-daemon} est configuré pour sauvegarder les journaux de construction compressés, comme c'est le cas par défaut (@pxref{Invoking guix-daemon}), les URL @code{/log} renvoient le journal compressé tel-quel, avec un en-tête @code{Content-Type} ou @code{Content-Encoding} approprié. Nous recommandons de lancer @command{guix-daemon} avec @code{--log-compression=gzip} pace que les navigateurs web les décompressent automatiquement, ce qui n'est pas le cas avec la compression bzip2." #. type: item #: doc/guix.texi:7723 #, no-wrap msgid "--port=@var{port}" -msgstr "" +msgstr "--port=@var{port}" #. type: itemx #: doc/guix.texi:7724 #, no-wrap msgid "-p @var{port}" -msgstr "" +msgstr "-p @var{port}" #. type: table #: doc/guix.texi:7726 msgid "Listen for HTTP requests on @var{port}." -msgstr "" +msgstr "Écoute les requêtes HTTP sur le @var{port}" #. type: item #: doc/guix.texi:7727 doc/guix.texi:17516 #, no-wrap msgid "--listen=@var{host}" -msgstr "" +msgstr "--listen=@var{hôte}" #. type: table #: doc/guix.texi:7730 msgid "Listen on the network interface for @var{host}. The default is to accept connections from any interface." -msgstr "" +msgstr "Écoute sur l'interface réseau de @var{hôte}. Par défaut, la commande accepte les connexions de n'importe quelle interface." #. type: table #: doc/guix.texi:7735 msgid "Change privileges to @var{user} as soon as possible---i.e., once the server socket is open and the signing key has been read." -msgstr "" +msgstr "Charge les privilèges de @var{utilisateur} le plus vite possible — c.-à-d. une fois que la socket du serveur est ouverte et que la clef de signature a été lue." #. type: item #: doc/guix.texi:7736 #, no-wrap msgid "--compression[=@var{level}]" -msgstr "" +msgstr "--compression[=@var{niveau}]" #. type: itemx #: doc/guix.texi:7737 #, no-wrap msgid "-C [@var{level}]" -msgstr "" +msgstr "-C [@var{niveau}]" #. type: table #: doc/guix.texi:7742 msgid "Compress data using the given @var{level}. When @var{level} is zero, disable compression. The range 1 to 9 corresponds to different gzip compression levels: 1 is the fastest, and 9 is the best (CPU-intensive). The default is 3." -msgstr "" +msgstr "Compresse les données au @var{niveau} donné. Lorsque le @var{niveau} est zéro, désactive la compression. L'intervalle 1 à 9 correspond aux différents niveaux de compression gzip : 1 est le plus rapide et 9 est la meilleure (mais gourmande en CPU). Le niveau par défaut est 3." #. type: table #: doc/guix.texi:7751 msgid "Unless @option{--cache} is used, compression occurs on the fly and the compressed streams are not cached. Thus, to reduce load on the machine that runs @command{guix publish}, it may be a good idea to choose a low compression level, to run @command{guix publish} behind a caching proxy, or to use @option{--cache}. Using @option{--cache} has the advantage that it allows @command{guix publish} to add @code{Content-Length} HTTP header to its responses." -msgstr "" +msgstr "À moins que @option{--cache} ne soit utilisé, la compression se fait à la volée et les flux compressés ne sont pas cachés. Ainsi, pour réduire la charge sur la machine qui fait tourner @command{guix publish}, c'est une bonne idée de choisir un niveau de compression faible, de lancer @command{guix publish} derrière un serveur de cache ou d'utiliser @option{--cache}. Utilise @option{--cache} a l'avantage qu'il permet à @command{guix publish} d'ajouter l'en-tête HTTP @code{Content-Length} à sa réponse." #. type: item #: doc/guix.texi:7752 #, no-wrap msgid "--cache=@var{directory}" -msgstr "" +msgstr "--cache=@var{répertoire}" #. type: itemx #: doc/guix.texi:7753 #, no-wrap msgid "-c @var{directory}" -msgstr "" +msgstr "-c @var{répertoire}" #. type: table #: doc/guix.texi:7756 msgid "Cache archives and meta-data (@code{.narinfo} URLs) to @var{directory} and only serve archives that are in cache." -msgstr "" +msgstr "Cache les archives et les métadonnées (les URL @code{.narinfo}) dans @var{répertoire} et ne sert que les archives dans ce cache." #. type: table #: doc/guix.texi:7764 msgid "When this option is omitted, archives and meta-data are created on-the-fly. This can reduce the available bandwidth, especially when compression is enabled, since this may become CPU-bound. Another drawback of the default mode is that the length of archives is not known in advance, so @command{guix publish} does not add a @code{Content-Length} HTTP header to its responses, which in turn prevents clients from knowing the amount of data being downloaded." -msgstr "" +msgstr "Lorsque cette option est omise, les archives et les métadonnées sont crées à la volée. Cela réduit la bande passante disponible, surtout quand la compression est activée puisqu'elle pourrait être limitée par le CPU. Un autre inconvénient au mode par défaut est que la taille des archives n'est pas connue à l'avance, donc @command{guix publish} n'ajoute pas l'en-tête @code{Content-Length} à ses résponses, ce qui empêche les clients de savoir la quantité de données à télécharger." #. type: table #: doc/guix.texi:7772 msgid "Conversely, when @option{--cache} is used, the first request for a store item (@i{via} a @code{.narinfo} URL) returns 404 and triggers a background process to @dfn{bake} the archive---computing its @code{.narinfo} and compressing the archive, if needed. Once the archive is cached in @var{directory}, subsequent requests succeed and are served directly from the cache, which guarantees that clients get the best possible bandwidth." -msgstr "" +msgstr "À l'inverse, lorsque @option{--cache} est utilisée, la première requête pour un élément du dépôt (via une URL @code{.narinfo}) renvoie une erreur 404 et déclenche la création de l'archive — en calculant son @code{.narinfo} et en compressant l'archive au besoin. Une fois l'archive cachée dans @var{répertoire}, les requêtes suivantes réussissent et sont servies directement depuis le cache, ce qui garanti que les clients ont la meilleure bande passante possible." #. type: table #: doc/guix.texi:7776 msgid "The ``baking'' process is performed by worker threads. By default, one thread per CPU core is created, but this can be customized. See @option{--workers} below." -msgstr "" +msgstr "Le processus de création est effectué par des threads de travail. Par défaut, un thread par cœur du CPU est créé, mais cela peut être personnalisé. Voir @option{--workers} plus bas." #. type: table #: doc/guix.texi:7779 msgid "When @option{--ttl} is used, cached entries are automatically deleted when they have expired." -msgstr "" +msgstr "Lorsque l'option @option{--ttl} est utilisée, les entrées cachées sont automatiquement supprimées lorsqu'elles expirent." #. type: item #: doc/guix.texi:7780 #, no-wrap msgid "--workers=@var{N}" -msgstr "" +msgstr "--workers=@var{N}" #. type: table #: doc/guix.texi:7783 msgid "When @option{--cache} is used, request the allocation of @var{N} worker threads to ``bake'' archives." -msgstr "" +msgstr "Lorsque @option{--cache} est utilisée, demande l'allocation de @var{N} thread de travail pour créer les archives." #. type: item #: doc/guix.texi:7784 #, no-wrap msgid "--ttl=@var{ttl}" -msgstr "" +msgstr "--ttl=@var{ttl}" #. type: table #: doc/guix.texi:7788 msgid "Produce @code{Cache-Control} HTTP headers that advertise a time-to-live (TTL) of @var{ttl}. @var{ttl} must denote a duration: @code{5d} means 5 days, @code{1m} means 1 month, and so on." -msgstr "" +msgstr "Produit des en-têtes HTTP @code{Cache-Control} qui expriment une durée de vie (TTL) de @var{ttl}. @var{ttl} peut dénoter une durée : @code{5d} signifie 5 jours, @code{1m} signifie un mois, etc." #. type: table #: doc/guix.texi:7793 msgid "This allows the user's Guix to keep substitute information in cache for @var{ttl}. However, note that @code{guix publish} does not itself guarantee that the store items it provides will indeed remain available for as long as @var{ttl}." -msgstr "" +msgstr "Cela permet au Guix de l'utilisateur de garder les informations en cache pendant @var{ttl}. Cependant, remarquez que @code{guix publish} ne garanti pas lui-même que les éléments du dépôt qu'il fournit seront toujours disponible pendant la durée @var{ttl}." #. type: table #: doc/guix.texi:7797 msgid "Additionally, when @option{--cache} is used, cached entries that have not been accessed for @var{ttl} and that no longer have a corresponding item in the store, may be deleted." -msgstr "" +msgstr "En plus, lorsque @option{--cache} est utilisée, les entrées cachées qui n'ont pas été demandé depuis @var{ttl} et n'ont pas d'élément correspondant dans le dépôt peuvent être supprimées." #. type: item #: doc/guix.texi:7798 #, no-wrap msgid "--nar-path=@var{path}" -msgstr "" +msgstr "--nar-path=@var{chemin}" #. type: table #: doc/guix.texi:7801 msgid "Use @var{path} as the prefix for the URLs of ``nar'' files (@pxref{Invoking guix archive, normalized archives})." -msgstr "" +msgstr "Utilise @var{chemin} comme préfixe des URL de fichier « nar » (@pxref{Invoking guix archive, normalized archives})." #. type: table #: doc/guix.texi:7805 msgid "By default, nars are served at a URL such as @code{/nar/gzip/@dots{}-coreutils-8.25}. This option allows you to change the @code{/nar} part to @var{path}." -msgstr "" +msgstr "Par défaut, les nars sont présents à l'URL comme @code{/nar/gzip/@dots{}-coreutils-8.25}. Cette option vous permet de changer la partie @code{/nar} en @var{chemin}." #. type: item #: doc/guix.texi:7806 #, no-wrap msgid "--public-key=@var{file}" -msgstr "" +msgstr "--public-key=@var{fichier}" #. type: itemx #: doc/guix.texi:7807 #, no-wrap msgid "--private-key=@var{file}" -msgstr "" +msgstr "--private-key=@var{fichier}" #. type: table #: doc/guix.texi:7810 msgid "Use the specific @var{file}s as the public/private key pair used to sign the store items being published." -msgstr "" +msgstr "Utilise les @var{fichier}s spécifiques comme pair de clefs utilisées pour signer les éléments avant de les publier." #. type: table #: doc/guix.texi:7817 msgid "The files must correspond to the same key pair (the private key is used for signing and the public key is merely advertised in the signature metadata). They must contain keys in the canonical s-expression format as produced by @command{guix archive --generate-key} (@pxref{Invoking guix archive}). By default, @file{/etc/guix/signing-key.pub} and @file{/etc/guix/signing-key.sec} are used." -msgstr "" +msgstr "Les fichiers doivent correspondre à la même pair de clefs (la clef privée est utilisée pour signer et la clef publique est seulement ajouté aux métadonnées de la signature). Ils doivent contenir les clefs dans le format s-expression canonique produit par @command{guix archive --generate-key} (@pxref{Invoking guix archive}). Par défaut, @file{/etc/guix/signing-key.pub} et @file{/etc/guix/signing-key.sec} sont utilisés." #. type: item #: doc/guix.texi:7818 #, no-wrap msgid "--repl[=@var{port}]" -msgstr "" +msgstr "--repl[=@var{port}]" #. type: itemx #: doc/guix.texi:7819 #, no-wrap msgid "-r [@var{port}]" -msgstr "" +msgstr "-r [@var{port}]" #. type: table #: doc/guix.texi:7823 msgid "Spawn a Guile REPL server (@pxref{REPL Servers,,, guile, GNU Guile Reference Manual}) on @var{port} (37146 by default). This is used primarily for debugging a running @command{guix publish} server." -msgstr "" +msgstr "Crée un serveur REPL Guile (@pxref{REPL Servers,,, guile, GNU Guile Reference Manual}) sur @var{pport} (37146 par défaut). C'est surtout utile pour déboguer un serveur @command{guix publish} qui tourne." #. type: Plain text #: doc/guix.texi:7829 msgid "Enabling @command{guix publish} on a GuixSD system is a one-liner: just instantiate a @code{guix-publish-service-type} service in the @code{services} field of the @code{operating-system} declaration (@pxref{guix-publish-service-type, @code{guix-publish-service-type}})." -msgstr "" +msgstr "Activer @command{guix publish} sur un système GuixSD est vraiment une seule ligne : instantiez simplement un service @code{guix-publish-service-type} dans le champs @code{services} de votre déclaration @code{operating-system} (@pxref{guix-publish-service-type, @code{guix-publish-service-type}})." #. type: Plain text #: doc/guix.texi:7832 msgid "If you are instead running Guix on a ``foreign distro'', follow these instructions:”" -msgstr "" +msgstr "Si vous avez installé Guix sur une « distro extérieure », suivez ces instructions :" #. type: itemize #: doc/guix.texi:7836 msgid "If your host distro uses the systemd init system:" -msgstr "" +msgstr "Si votre distro hôte utilise le système d'init systemd :" #. type: example #: doc/guix.texi:7841 @@ -13972,6 +14269,9 @@ msgid "" " /etc/systemd/system/\n" "# systemctl start guix-publish && systemctl enable guix-publish\n" msgstr "" +"# ln -s ~root/.guix-profile/lib/systemd/system/guix-publish.service \\\n" +" /etc/systemd/system/\n" +"# systemctl start guix-publish && systemctl enable guix-publish\n" #. type: example #: doc/guix.texi:7849 @@ -13980,40 +14280,42 @@ msgid "" "# ln -s ~root/.guix-profile/lib/upstart/system/guix-publish.conf /etc/init/\n" "# start guix-publish\n" msgstr "" +"# ln -s ~root/.guix-profile/lib/upstart/system/guix-publish.conf /etc/init/\n" +"# start guix-publish\n" #. type: itemize #: doc/guix.texi:7853 msgid "Otherwise, proceed similarly with your distro's init system." -msgstr "" +msgstr "Sinon, procédez de manière similaire avec votre système d'init de votre distro." #. type: section #: doc/guix.texi:7856 #, no-wrap msgid "Invoking @command{guix challenge}" -msgstr "" +msgstr "Invoquer @command{guix challenge}" #. type: cindex #: doc/guix.texi:7859 #, no-wrap msgid "verifiable builds" -msgstr "" +msgstr "constructions vérifiables" #. type: command{#1} #: doc/guix.texi:7860 #, no-wrap msgid "guix challenge" -msgstr "" +msgstr "guix challenge" #. type: cindex #: doc/guix.texi:7861 #, no-wrap msgid "challenge" -msgstr "" +msgstr "défi" #. type: Plain text #: doc/guix.texi:7866 msgid "Do the binaries provided by this server really correspond to the source code it claims to build? Is a package build process deterministic? These are the questions the @command{guix challenge} command attempts to answer." -msgstr "" +msgstr "Est-ce que les binaires fournis par ce serveur correspondent réellement au code source qu'il dit avoir construit ? Est-ce que le processus de construction d'un paquet est déterministe ? Ce sont les question auxquelles la commande @command{guix challenge} essaye de répondre." #. type: Plain text #: doc/guix.texi:7874 @@ -14023,12 +14325,12 @@ msgstr "La première question est évidemment importante : avant d'utiliser un #. type: Plain text #: doc/guix.texi:7883 msgid "We know that the hash that shows up in @file{/gnu/store} file names is the hash of all the inputs of the process that built the file or directory---compilers, libraries, build scripts, etc. (@pxref{Introduction}). Assuming deterministic build processes, one store file name should map to exactly one build output. @command{guix challenge} checks whether there is, indeed, a single mapping by comparing the build outputs of several independent builds of any given store item." -msgstr "" +msgstr "On sait que le hash qui apparaît dans @file{/gnu/store} est le hash de toutes les entrées du processus qui construit le fichier ou le répertoire — les compilateurs, les bibliothèques, les scripts de construction, etc. (@pxref{Introduction}). En supposant que les processus de construction sont déterministes, un nom de fichier dans le dépôt devrait correspondre exactement à une sortie de construction. @command{guix challenge} vérifie si il y a bien effectivement une seule correspondance en comparant les sorties de plusieurs constructions indépendantes d'un élément du dépôt donné." #. type: Plain text #: doc/guix.texi:7885 msgid "The command output looks like this:" -msgstr "" +msgstr "La sortie de la commande ressemble à :" #. type: smallexample #: doc/guix.texi:7902 @@ -14051,6 +14353,22 @@ msgid "" " https://guix.example.org/nar/@dots{}-pius-2.1.1: 1cy25x1a4fzq5rk0pmvc8xhwyffnqz95h2bpvqsz2mpvlbccy0gs\n" "\n" msgstr "" +"$ guix challenge --substitute-urls=\"https://hydra.gnu.org https://guix.example.org\"\n" +"mise à jour de la liste des substituts depuis 'https://hydra.gnu.org'... 100.0%\n" +"mise à jour de la liste des substituts depuis 'https://guix.example.org'... 100.0%\n" +"le contenu de /gnu/store/@dots{}-openssl-1.0.2d diffère :\n" +" empreinte locale : 0725l22r5jnzazaacncwsvp9kgf42266ayyp814v7djxs7nk963q\n" +" https://hydra.gnu.org/nar/@dots{}-openssl-1.0.2d : 0725l22r5jnzazaacncwsvp9kgf42266ayyp814v7djxs7nk963q\n" +" https://guix.example.org/nar/@dots{}-openssl-1.0.2d : 1zy4fmaaqcnjrzzajkdn3f5gmjk754b43qkq47llbyak9z0qjyim\n" +"le contenu de /gnu/store/@dots{}-git-2.5.0 diffère :\n" +" empreinte locale : 00p3bmryhjxrhpn2gxs2fy0a15lnip05l97205pgbk5ra395hyha\n" +" https://hydra.gnu.org/nar/@dots{}-git-2.5.0 : 069nb85bv4d4a6slrwjdy8v1cn4cwspm3kdbmyb81d6zckj3nq9f\n" +" https://guix.example.org/nar/@dots{}-git-2.5.0 : 0mdqa9w1p6cmli6976v4wi0sw9r4p5prkj7lzfd1877wk11c9c73\n" +"le contenu de /gnu/store/@dots{}-pius-2.1.1 diffère :\n" +" empreinte locale : 0k4v3m9z1zp8xzzizb7d8kjj72f9172xv078sq4wl73vnq9ig3ax\n" +" https://hydra.gnu.org/nar/@dots{}-pius-2.1.1 : 0k4v3m9z1zp8xzzizb7d8kjj72f9172xv078sq4wl73vnq9ig3ax\n" +" https://guix.example.org/nar/@dots{}-pius-2.1.1 : 1cy25x1a4fzq5rk0pmvc8xhwyffnqz95h2bpvqsz2mpvlbccy0gs\n" +"\n" #. type: smallexample #: doc/guix.texi:7904 @@ -14059,6 +14377,8 @@ msgid "" "@dots{}\n" "\n" msgstr "" +"@dots{}\n" +"\n" #. type: smallexample #: doc/guix.texi:7909 @@ -14069,27 +14389,31 @@ msgid "" " - 525 (8.2%) differed\n" " - 1,132 (17.7%) were inconclusive\n" msgstr "" +"6,406 éléments du dépôt ont été analysés :\n" +" - 4,749 (74.1%) étaient identiques\n" +" - 525 (8.2%) étaient différents\n" +" - 1,132 (17.7%) étaient impossibles à évaluer\n" #. type: Plain text #: doc/guix.texi:7917 msgid "In this example, @command{guix challenge} first scans the store to determine the set of locally-built derivations---as opposed to store items that were downloaded from a substitute server---and then queries all the substitute servers. It then reports those store items for which the servers obtained a result different from the local build." -msgstr "" +msgstr "Dans cet exemple, @command{guix challenge} scanne d'abord le dépôt pour déterminer l'ensemble des dérivations construites localement — en opposition aux éléments qui ont été téléchargées depuis un serveur de substituts — puis demande leur avis à tous les serveurs de substituts. Il rapporte ensuite les éléments du dépôt pour lesquels les serveurs ont obtenu un résultat différent de la construction locale." #. type: cindex #: doc/guix.texi:7918 #, no-wrap msgid "non-determinism, in package builds" -msgstr "" +msgstr "non-déterminisme, dans les constructions des paquets" #. type: Plain text #: doc/guix.texi:7929 msgid "As an example, @code{guix.example.org} always gets a different answer. Conversely, @code{hydra.gnu.org} agrees with local builds, except in the case of Git. This might indicate that the build process of Git is non-deterministic, meaning that its output varies as a function of various things that Guix does not fully control, in spite of building packages in isolated environments (@pxref{Features}). Most common sources of non-determinism include the addition of timestamps in build results, the inclusion of random numbers, and directory listings sorted by inode number. See @uref{https://reproducible-builds.org/docs/}, for more information." -msgstr "" +msgstr "Dans l'exemple, @code{guix.example.org} obtient toujours une réponse différente. Inversement, @code{hydra.gnu.org} est d'accord avec les constructions locale, sauf dans le cas de Git. Cela peut indiquer que le processus de construction de Git est non-déterministe, ce qui signifie que sa sortie diffère en fonction de divers choses que Guix ne contrôle pas parfaitement, malgré l'isolation des constructions (@pxref{Features}). Les sources les plus communes de non-déterminisme comprennent l'ajout d'horodatage dans les résultats des constructions, l'inclusion de nombres aléatoires et des listes de fichiers ordonnés par numéro d'inœud. Voir @uref{https://reproducible-builds.org/docs/}, pour plus d'informations." #. type: Plain text #: doc/guix.texi:7932 msgid "To find out what is wrong with this Git binary, we can do something along these lines (@pxref{Invoking guix archive}):" -msgstr "" +msgstr "Pour trouver ce qui ne va pas avec le binaire de Git, on peut faire quelque chose comme cela (@pxref{Invoking guix archive}) :" #. type: example #: doc/guix.texi:7937 @@ -14099,99 +14423,102 @@ msgid "" " | guix archive -x /tmp/git\n" "$ diff -ur --no-dereference /gnu/store/@dots{}-git.2.5.0 /tmp/git\n" msgstr "" +"$ wget -q -O - https://hydra.gnu.org/nar/@dots{}-git-2.5.0 \\\n" +" | guix archive -x /tmp/git\n" +"$ diff -ur --no-dereference /gnu/store/@dots{}-git.2.5.0 /tmp/git\n" #. type: Plain text #: doc/guix.texi:7946 msgid "This command shows the difference between the files resulting from the local build, and the files resulting from the build on @code{hydra.gnu.org} (@pxref{Overview, Comparing and Merging Files,, diffutils, Comparing and Merging Files}). The @command{diff} command works great for text files. When binary files differ, a better option is @uref{https://diffoscope.org/, Diffoscope}, a tool that helps visualize differences for all kinds of files." -msgstr "" +msgstr "Cette commande montre les différences entre les fichiers qui résultent de la construction locale et des fichiers qui résultent de la construction sur @code{hydra.gnu.org} (@pxref{Overview, Comparing and Merging Files,, diffutils, Comparing and Merging Files}). La commande @command{diff} fonctionne bien avec des fichiers texte. Lorsque des fichiers binaires diffèrent cependant, @uref{https://diffoscope.org/, Diffoscope} est une meilleure option. C'est un outil qui aide à visualiser les différences entre toute sorte de fichiers." #. type: Plain text #: doc/guix.texi:7954 msgid "Once you have done that work, you can tell whether the differences are due to a non-deterministic build process or to a malicious server. We try hard to remove sources of non-determinism in packages to make it easier to verify substitutes, but of course, this is a process that involves not just Guix, but a large part of the free software community. In the meantime, @command{guix challenge} is one tool to help address the problem." -msgstr "" +msgstr "Une fois que vous avez fait ce travail, vous pourrez dire si les différences sont dues au non-déterminisme du processus de construction ou à la malhonnêteté du serveur. Nous avons fait beaucoup d'effort pour éliminer les sources de non-déterminisme dans les paquets pour rendre plus facile la vérification des substituts, mais bien sûr, c'est un processus qui n'implique pas que Guix, mais une grande partie de la communauté des logiciels libres. Pendant ce temps, @command{guix challenge} est un outil pour aider à corriger le problème." #. type: Plain text #: doc/guix.texi:7958 msgid "If you are writing packages for Guix, you are encouraged to check whether @code{hydra.gnu.org} and other substitute servers obtain the same build result as you did with:" -msgstr "" +msgstr "Si vous écrivez un paquet pour Guix, nous vous encourageons à vérifier si @code{hydra.gnu.org} et d'autres serveurs de substituts obtiennent le même résultat que vous avec :" #. type: example #: doc/guix.texi:7961 #, no-wrap msgid "$ guix challenge @var{package}\n" -msgstr "" +msgstr "$ guix challenge @var{paquet}\n" #. type: Plain text #: doc/guix.texi:7966 msgid "where @var{package} is a package specification such as @code{guile@@2.0} or @code{glibc:debug}." -msgstr "" +msgstr "où @var{paquet} est une spécification de paquet comme @code{guile@@2.0} ou @code{glibc:debug}." #. type: example #: doc/guix.texi:7971 #, no-wrap msgid "guix challenge @var{options} [@var{packages}@dots{}]\n" -msgstr "" +msgstr "guix challenge @var{options} [@var{paquets}@dots{}]\n" #. type: Plain text #: doc/guix.texi:7978 msgid "When a difference is found between the hash of a locally-built item and that of a server-provided substitute, or among substitutes provided by different servers, the command displays it as in the example above and its exit code is 2 (other non-zero exit codes denote other kinds of errors.)" -msgstr "" +msgstr "Lorsqu'une différence est trouvée entre l'empreinte d'un élément construit localement et celle d'un substitut fournit par un serveur, ou parmi les substituts fournis par différents serveurs, la commande l'affiche comme dans l'exemple ci-dessus et sa valeur de sortie est 2 (les autres valeurs différentes de 0 indiquent d'autres sortes d'erreurs)." #. type: Plain text #: doc/guix.texi:7980 msgid "The one option that matters is:" -msgstr "" +msgstr "L'option qui compte est :" #. type: table #: doc/guix.texi:7986 msgid "Consider @var{urls} the whitespace-separated list of substitute source URLs to compare to." -msgstr "" +msgstr "Considère @var{urls} comme la liste des URL des sources de substituts séparés par des espaces avec lesquels comparer les paquets locaux." #. type: itemx #: doc/guix.texi:7988 #, no-wrap msgid "-v" -msgstr "" +msgstr "-v" #. type: table #: doc/guix.texi:7991 msgid "Show details about matches (identical contents) in addition to information about mismatches." -msgstr "" +msgstr "Montre des détails sur les correspondances (contenu identique) en plus des informations sur différences." #. type: section #: doc/guix.texi:7995 #, no-wrap msgid "Invoking @command{guix copy}" -msgstr "" +msgstr "Invoquer @command{guix copy}" #. type: cindex #: doc/guix.texi:7997 #, no-wrap msgid "copy, of store items, over SSH" -msgstr "" +msgstr "copier des éléments du dépôt par SSH" #. type: cindex #: doc/guix.texi:7998 #, no-wrap msgid "SSH, copy of store items" -msgstr "" +msgstr "SSH, copie d'éléments du dépôt" #. type: cindex #: doc/guix.texi:7999 #, no-wrap msgid "sharing store items across machines" -msgstr "" +msgstr "partager des éléments du dépôt entre plusieurs machines" #. type: cindex #: doc/guix.texi:8000 #, no-wrap msgid "transferring store items across machines" -msgstr "" +msgstr "transférer des éléments du dépôt entre plusieurs machines" #. type: Plain text #: doc/guix.texi:8007 msgid "The @command{guix copy} command copies items from the store of one machine to that of another machine over a secure shell (SSH) connection@footnote{This command is available only when Guile-SSH was found. @xref{Requirements}, for details.}. For example, the following command copies the @code{coreutils} package, the user's profile, and all their dependencies over to @var{host}, logged in as @var{user}:" -msgstr "" +msgstr "La commande @command{guix copy} copie des éléments du dépôt d'une machine vers le dépôt d'une autre machine à travers une connexion SSH@footnote{Cette commande n'est disponible que si Guile-SSH est trouvé. @xref{Requirements}, pour des détails}. Par exemple, la commande suivante copie le paquet @code{coreutils}, le profil utilisateur et toutes leurs dépendances sur @var{hôte}, en tant qu'utilisateur @var{utilisateur} :" #. type: example #: doc/guix.texi:8011 @@ -14200,157 +14527,159 @@ msgid "" "guix copy --to=@var{user}@@@var{host} \\\n" " coreutils `readlink -f ~/.guix-profile`\n" msgstr "" +"guix copy --to=@var{utilisateur}@@@var{hôte} \\\n" +" coreutils `readlink -f ~/.guix-profile`\n" #. type: Plain text #: doc/guix.texi:8015 msgid "If some of the items to be copied are already present on @var{host}, they are not actually sent." -msgstr "" +msgstr "Si certains éléments à copier sont déjà présents sur @var{hôte}, ils ne sont pas envoyés." #. type: Plain text #: doc/guix.texi:8018 msgid "The command below retrieves @code{libreoffice} and @code{gimp} from @var{host}, assuming they are available there:" -msgstr "" +msgstr "La commande ci-dessous récupère @code{libreoffice} et @code{gimp} depuis @var{hôte}, en supposant qu'ils y sont présents :" #. type: example #: doc/guix.texi:8021 #, no-wrap msgid "guix copy --from=@var{host} libreoffice gimp\n" -msgstr "" +msgstr "guix copy --from=@var{hôte} libreoffice gimp\n" #. type: Plain text #: doc/guix.texi:8026 msgid "The SSH connection is established using the Guile-SSH client, which is compatible with OpenSSH: it honors @file{~/.ssh/known_hosts} and @file{~/.ssh/config}, and uses the SSH agent for authentication." -msgstr "" +msgstr "La connexion SSH est établie avec le client Guile-SSH, qui set compatible avec OpenSSH : il honore @file{~/.ssh/known_hosts} et @file{~/.ssh/config} et utilise l'agent SSH pour l'authentification." #. type: Plain text #: doc/guix.texi:8032 msgid "The key used to sign items that are sent must be accepted by the remote machine. Likewise, the key used by the remote machine to sign items you are retrieving must be in @file{/etc/guix/acl} so it is accepted by your own daemon. @xref{Invoking guix archive}, for more information about store item authentication." -msgstr "" +msgstr "La clef utilisée pour signer les éléments qui sont envoyés doit être acceptée par la machine distante. De même, la clef utilisée pour la machine distante depuis laquelle vous récupérez des éléments doit être dans @file{/etc/guix/acl} pour qu'ils soient acceptés par votre propre démon. @xref{Invoking guix archive}, pour plus d'informations sur l'authentification des éléments du dépôt." #. type: example #: doc/guix.texi:8037 #, no-wrap msgid "guix copy [--to=@var{spec}|--from=@var{spec}] @var{items}@dots{}\n" -msgstr "" +msgstr "guix copy [--to=@var{spec}|--from=@var{spec}] @var{items}@dots{}\n" #. type: Plain text #: doc/guix.texi:8040 msgid "You must always specify one of the following options:" -msgstr "" +msgstr "Vous devez toujours spécifier l'une des options suivantes :" #. type: item #: doc/guix.texi:8042 #, no-wrap msgid "--to=@var{spec}" -msgstr "" +msgstr "--to=@var{spec}" #. type: itemx #: doc/guix.texi:8043 #, no-wrap msgid "--from=@var{spec}" -msgstr "" +msgstr "--from=@var{spec}" #. type: table #: doc/guix.texi:8047 msgid "Specify the host to send to or receive from. @var{spec} must be an SSH spec such as @code{example.org}, @code{charlie@@example.org}, or @code{charlie@@example.org:2222}." -msgstr "" +msgstr "Spécifie l'hôte où envoyer ou d'où recevoir les éléments. @var{spec} doit être une spécification SSH comme @code{example.org}, @code{charlie@@example.org} ou @code{charlie@@example.org:2222}." #. type: Plain text #: doc/guix.texi:8051 msgid "The @var{items} can be either package names, such as @code{gimp}, or store items, such as @file{/gnu/store/@dots{}-idutils-4.6}." -msgstr "" +msgstr "L'option @var{items} peut être des noms de paquets, comme @code{gimp} ou des éléments du dépôt comme @file{/gnu/store/@dots{}-idutils-4.6}." #. type: Plain text #: doc/guix.texi:8055 msgid "When specifying the name of a package to send, it is first built if needed, unless @option{--dry-run} was specified. Common build options are supported (@pxref{Common Build Options})." -msgstr "" +msgstr "Lorsque vous spécifiez le nom d'un paquet à envoyer, il est d'abord construit au besoin, sauf si l'option @option{--dry-run} est spécifiée. Les options de construction communes sont supportées (@pxref{Common Build Options})." #. type: section #: doc/guix.texi:8058 #, no-wrap msgid "Invoking @command{guix container}" -msgstr "" +msgstr "Invoquer @command{guix container}" #. type: command{#1} #: doc/guix.texi:8060 #, no-wrap msgid "guix container" -msgstr "" +msgstr "guix container" #. type: quotation #: doc/guix.texi:8064 msgid "As of version @value{VERSION}, this tool is experimental. The interface is subject to radical change in the future." -msgstr "" +msgstr "À la version @value{VERSION}, cet outil est toujours expérimental. L'interface est sujette à changement radicaux dans le futur." #. type: Plain text #: doc/guix.texi:8071 msgid "The purpose of @command{guix container} is to manipulate processes running within an isolated environment, commonly known as a ``container'', typically created by the @command{guix environment} (@pxref{Invoking guix environment}) and @command{guix system container} (@pxref{Invoking guix system}) commands." -msgstr "" +msgstr "Le but de @command{guix container} est de manipuler des processus qui tournent dans un environnement séparé, connus sous le nom de « conteneur », typiquement créés par les commandes @command{guix environment} (@pxref{Invoking guix environment}) et @command{guix system container} (@pxref{Invoking guix system})." #. type: example #: doc/guix.texi:8076 #, no-wrap msgid "guix container @var{action} @var{options}@dots{}\n" -msgstr "" +msgstr "guix container @var{action} @var{options}@dots{}\n" #. type: Plain text #: doc/guix.texi:8080 msgid "@var{action} specifies the operation to perform with a container, and @var{options} specifies the context-specific arguments for the action." -msgstr "" +msgstr "@var{action} spécifie les opérations à effectuer avec un conteneur, et @var{options} spécifie les arguments spécifiques au contexte pour l'action." #. type: Plain text #: doc/guix.texi:8082 msgid "The following actions are available:" -msgstr "" +msgstr "Les actions suivantes sont disponibles :" #. type: item #: doc/guix.texi:8084 #, no-wrap msgid "exec" -msgstr "" +msgstr "exec" #. type: table #: doc/guix.texi:8086 msgid "Execute a command within the context of a running container." -msgstr "" +msgstr "Exécute une commande dans le contexte d'un conteneur lancé." #. type: table #: doc/guix.texi:8088 msgid "The syntax is:" -msgstr "" +msgstr "La syntaxe est :" #. type: example #: doc/guix.texi:8091 #, no-wrap msgid "guix container exec @var{pid} @var{program} @var{arguments}@dots{}\n" -msgstr "" +msgstr "guix container exec @var{pid} @var{programme} @var{arguments}@dots{}\n" #. type: table #: doc/guix.texi:8097 msgid "@var{pid} specifies the process ID of the running container. @var{program} specifies an executable file name within the root file system of the container. @var{arguments} are the additional options that will be passed to @var{program}." -msgstr "" +msgstr "@var{pid} spécifie le PID du conteneur lancé. @var{programme} spécifie le nom du fichier exécutable dans le système de fichiers racine du conteneur. @var{arguments} sont les options supplémentairesà passer à @var{programme}." #. type: table #: doc/guix.texi:8101 msgid "The following command launches an interactive login shell inside a GuixSD container, started by @command{guix system container}, and whose process ID is 9001:" -msgstr "" +msgstr "La commande suivante lance un shell de connexion interactif dans un conteneur GuixSD, démarré par @command{guix system container} et dont le PID est 9001 :" #. type: example #: doc/guix.texi:8104 #, no-wrap msgid "guix container exec 9001 /run/current-system/profile/bin/bash --login\n" -msgstr "" +msgstr "guix container exec 9001 /run/current-system/profile/bin/bash --login\n" #. type: table #: doc/guix.texi:8108 msgid "Note that the @var{pid} cannot be the parent process of a container. It must be PID 1 of the container or one of its child processes." -msgstr "" +msgstr "Remarquez que @var{pid} ne peut pas être le processus parent d'un conteneur. Ce doit être le PID 1 du conteneur ou l'un de ses processus fils." #. type: section #: doc/guix.texi:8112 #, no-wrap msgid "Invoking @command{guix weather}" -msgstr "" +msgstr "Invoquer @command{guix weather}" #. type: Plain text #: doc/guix.texi:8121 @@ -14361,30 +14690,30 @@ msgstr "Vous pouvez parfois grogner lorsque les substituts ne sont pas disponibl #: doc/guix.texi:8122 #, no-wrap msgid "statistics, for substitutes" -msgstr "" +msgstr "statistiques sur les substituts" #. type: cindex #: doc/guix.texi:8123 #, no-wrap msgid "availability of substitutes" -msgstr "" +msgstr "disponibilité des substituts" #. type: cindex #: doc/guix.texi:8124 #, no-wrap msgid "substitute availability" -msgstr "" +msgstr "substuts, disponibilité" #. type: cindex #: doc/guix.texi:8125 #, no-wrap msgid "weather, substitute availability" -msgstr "" +msgstr "weather, disponibilité des substituts" #. type: Plain text #: doc/guix.texi:8127 msgid "Here's a sample run:" -msgstr "" +msgstr "Voici un exemple :" #. type: example #: doc/guix.texi:8139 @@ -14402,6 +14731,17 @@ msgid "" " 33.5 requests per second\n" "\n" msgstr "" +"$ guix weather --substitute-urls=https://guix.example.org\n" +"calcul de 5,872 dérivations de paquets pour x86_64-linux…\n" +"recherche de 6,128 éléments du dépôt sur https://guix.example.org…\n" +"mise à jour de la liste des substituts depuis 'https://guix.example.org'... 100.0%\n" +"https://guix.example.org\n" +" 43.4% substituts disponibles (2,658 sur 6,128)\n" +" 7,032.5 Mo de fichiers nar (compressés)\n" +" 19,824.2 Mo sur le disque (décompressés)\n" +" 0.030 secondes par requêtes (182.9 secondes au total)\n" +" 33.5 requêtes par seconde\n" +"\n" #. type: example #: doc/guix.texi:8149 @@ -14417,47 +14757,56 @@ msgid "" " i686-linux: 6.03 builds per hour\n" " aarch64-linux: 6.41 builds per hour\n" msgstr "" +" 9.8% (342 sur 3,470) des éléments manquants sont dans la queue\n" +" 867 constructions dans la queue\n" +" x86_64-linux : 518 (59.7%)\n" +" i686-linux : 221 (25.5%)\n" +" aarch64-linux : 128 (14.8%)\n" +" vitesse de construction : 23.41 constructions par heure\n" +" x86_64-linux : 11.16 constructions par heure\n" +" i686-linux : 6.03 constructions par heure\n" +" aarch64-linux : 6.41 constructions par heure\n" #. type: cindex #: doc/guix.texi:8151 #, no-wrap msgid "continuous integration, statistics" -msgstr "" +msgstr "intégration continue, statistiques" #. type: Plain text #: doc/guix.texi:8160 msgid "As you can see, it reports the fraction of all the packages for which substitutes are available on the server---regardless of whether substitutes are enabled, and regardless of whether this server's signing key is authorized. It also reports the size of the compressed archives (``nars'') provided by the server, the size the corresponding store items occupy in the store (assuming deduplication is turned off), and the server's throughput. The second part gives continuous integration (CI) statistics, if the server supports it." -msgstr "" +msgstr "Comme vous pouvez le voir, elle rapporte le pourcentage des paquets pour lesquels des substituts sont disponibles sur le serveur — indépendamment du fait que les substituts soient activés, et indépendamment du fait que la clef de signature du serveur soit autorisée. Elle rapporte aussi la taille des archives compressées fournies par le serveur, la taille des éléments du dépôt correspondant dans le dépôt (en supposant que la déduplication soit désactivée) et la vitesse du serveur. La deuxième partie donne des statistiques sur l'intégration continue (CI), si le serveur le supporte." #. type: Plain text #: doc/guix.texi:8166 msgid "To achieve that, @command{guix weather} queries over HTTP(S) meta-data (@dfn{narinfos}) for all the relevant store items. Like @command{guix challenge}, it ignores signatures on those substitutes, which is innocuous since the command only gathers statistics and cannot install those substitutes." -msgstr "" +msgstr "Pour cela, @command{guix weather} récupère par HTTP(S) les métadonnées (@dfn{narinfos}@ de tous les éléments du dépôts pertinents. Comme @command{guix challenge}, il ignore les signatures de ces substituts, ce qui n'est pas dangereux puisque la commande ne fait que récupérer des statistiques et n'installe pas ces substituts." #. type: Plain text #: doc/guix.texi:8169 msgid "Among other things, it is possible to query specific system types and specific package sets. The available options are listed below." -msgstr "" +msgstr "Entre autres choses, il est possible de demander des types de système particuliers et des ensembles de paquets particuliers. Les options disponibles sont listées plus bas." #. type: table #: doc/guix.texi:8175 msgid "@var{urls} is the space-separated list of substitute server URLs to query. When this option is omitted, the default set of substitute servers is queried." -msgstr "" +msgstr "@var{urls} est la liste des URL des serveurs de substituts séparés par des espaces. Lorsque cette option n'est pas renseignée, l'ensemble des serveurs de substituts par défaut est utilisé." #. type: table #: doc/guix.texi:8181 msgid "Query substitutes for @var{system}---e.g., @code{aarch64-linux}. This option can be repeated, in which case @command{guix weather} will query substitutes for several system types." -msgstr "" +msgstr "Effectue des requêtes pour les substituts @var{système} — p.@: ex.@: @code{aarch64-linux}. Cette option peut être répétée, auquel cas @command{guix weather} demandera les substituts de plusieurs types de systèmes." #. type: table #: doc/guix.texi:8187 msgid "Instead of querying substitutes for all the packages, only ask for those specified in @var{file}. @var{file} must contain a @dfn{manifest}, as with the @code{-m} option of @command{guix package} (@pxref{Invoking guix package})." -msgstr "" +msgstr "Plutôt que de demander des substituts pour tous les paquets, demande uniquement les paquets spécifiés dans @var{fichier}. @var{fichier} doit contenir un @dfn{manifeste} comme avec l'option @code{-m} de @command{guix package} (@pxref{Invoking guix package})." #. type: Plain text #: doc/guix.texi:8205 msgid "Guix comes with a distribution of the GNU system consisting entirely of free software@footnote{The term ``free'' here refers to the @url{http://www.gnu.org/philosophy/free-sw.html,freedom provided to users of that software}.}. The distribution can be installed on its own (@pxref{System Installation}), but it is also possible to install Guix as a package manager on top of an installed GNU/Linux system (@pxref{Installation}). To distinguish between the two, we refer to the standalone distribution as the Guix System Distribution, or GuixSD." -msgstr "" +msgstr "Guix fournit aussi une distribution du système GNU contenant uniquement des logiciels libres@footnote{Le terme « libre » se réfère ici bien sûr à @url{http://www.gnu.org/philosophy/free-sw.fr.html,la liberté offerte à l'utilisateur de ces logiciels}.}. On peut installer la distribution elle-même (@pxref{System Installation}), mais on peut aussi installer Guix comme gestionnaire de paquets par dessus un système GNU/Linux déjà installé (@pxref{Installation}). Pour distinguer ces deux cas, on appelle la distribution autonome « Distribution Système Guix » ou GuixSD." #. type: Plain text #: doc/guix.texi:8211