Langage de programmation - Clojure - Référence de l'interface de ligne de commande Clojure (CLI)

Référence de l'interface de ligne de commande Clojure (CLI)

L'interface de ligne de commande Clojure (CLI) permet d'exécuter des programmes Clojure sur la machine virtuelle Java (JVM). Elle utilise des fichiers deps.edn pour configurer et télécharger les dépendances du programme afin de les inclure dans le classpath de la JVM.

Installation

L'interface de ligne de commande Clojure (CLI) peut être installée de différentes manières. Consultez le guide d'installation pour plus de détails et la page de la version pour les informations de version. Vous pouvez également consulter le guide pour un tutoriel plus complet. Pour la génération d'artefacts, consultez le guide tools.build.

Toute version de la CLI Clojure est compatible avec toutes les versions du langage Clojure. Il est généralement recommandé d'utiliser la dernière version de la CLI pour bénéficier des dernières fonctionnalités et corrections. Si vous spécifiez une version de la CLI A.B.C[.D], la version de Clojure utilisée par défaut dans le REPL sera A.B.C. Vous pouvez cependant spécifier une version plus ancienne (ou plus récente !) du langage dans vos dépendances.

Utilisation

L'interface en ligne de commande (CLI) s'utilise via `clojure` ou `clj`. Ces deux commandes sont généralement interchangeables, mais `clj` inclut `rlwrap` pour des fonctionnalités d'édition de texte étendues, particulièrement utiles avec l'interpréteur interactif (REPL). Ce guide utilise `clj` pour les exemples avec REPL et `clojure` pour les autres.

Chaque exécution de la CLI Clojure lance un programme Clojure en déterminant tous les chemins d'accès, les dépendances et le point d'entrée principal, puis en invoquant le programme sur la JVM. Le mode d'exécution principal est déterminé par les options `-X`, `-T` et `-M` (ou leur absence). La configuration est définie par un ou plusieurs fichiers `deps.edn` combinés aux options de la ligne de commande.

Commandes principales

Démarrer un REPL (par défaut) :

clj [clj-opts] [-Aaliases]

Exécuter une fonction (-X) :

clojure [clj-opts] -X[aliases] my/fn? [kpath v ...] kv-map?

Exécuter un outil (-T) :

clojure [clj-opts] -T[name|aliases] my/fn [kpath v ...] kv-map?

Exécuter l'espace de noms principal ou le script (-M) :

clojure [clj-opts] -M[aliases] [init-opts] [main-opts] [args]

Index d'options

Paramètre	Description
exec-opts	Les options d'exécutions :
	Paramètre	Description
	-Aaliases	Appliquer des alias
	-X[aliases]	Appeler la fonction en utilisant des alias
	-Ttoolname	Appeler l'outil par son nom local
	-T[aliases]	Appeler l'outil à l'aide d'alias
	-M[aliases]	Appelez clojure.main en utilisant des alias
	-P	Préparez les dépendances mais n'exécutez pas
clj-opts	Les options CLJ :
	Paramètre	Description
	-Jopt	Passer l'option JVM
	-Sdeps EDN	Données ou fichier deps.edn supplémentaires
	-Srepro	Ignorer le fichier deps.edn de l'utilisateur
	-Spath	Calculer et afficher le classpath
	-Stree	Arbre de dépendance d'affichage
	-Scp CP	Utilisez ce classpath, ignorez deps.edn
	-Sforce	Calcul du classpath de force
	-Sverbose	Informations sur le chemin d'impression
	-Sthreads	Définir un nombre précis de processus léger de téléchargement
	-Strace	Écrire dep expansion trace.edn
	--version	Afficher la version sur la sortie standard et quitter
	-version	Afficher la version sur stderr et quitter
	--help -h -?	Afficher ce message d'aide
deps	Programmes fournis par :deps alias :
	Paramètre	Description
	-X:deps list	Liste des dépendances affichées + licences
	-X:deps tree	Arbre des dépendances d'affichage
	-X:deps find-versions	Trouver les versions de bibliothèque disponibles
	-X:deps prep	Préparer toutes les bibliothèques non préparées dans les dépendances
	-X:deps mvn-pom	Générer le fichier pom.xml pour deps.edn
	-X:deps mvn-install	Installer le fichier JAR Maven dans le dépôt local

Lancer un REPL

Utilisez cette option pour lancer un REPL Clojure.

clj [clj-opts] [-Aaliases]

Pour exécuter une interface REPL, invoquez `clj` sans arguments.

Cela fonctionne dans n'importe quel répertoire, qu'il contienne ou non un fichier `deps.edn`. Si vous n'êtes pas dans un répertoire de projet, la version de Clojure utilisée dépendra de la version du langage Clojure définie par la dépendance `org.clojure` dans le fichier `deps.edn` racine (elle correspondra au numéro de version affiché dans l'interface de ligne de commande) ou du fichier `deps.edn` utilisateur dans le répertoire de configuration (généralement non spécifié).

Pour fournir des alias modifiant le classpath ou les propriétés de la JVM, utilisez l'option `-A` suivie d'un ou plusieurs mots-clefs d'alias :

clj -A:test
clj -A:test:dev

Exécuter une fonction (-X)

L'interface de ligne de commande Clojure peut exécuter n'importe quelle fonction du classpath du projet qui prend des arguments nommés dans une cartographie en entrée.

clojure [clj-opt*] -X[aliases] [a/fn] [kpath v]* kv-map?

L'exécution d'une fonction nécessite les informations suivantes :

Classpath (chemin de classe) - basé sur les sources des dépendances et les alias
Fonction à exécuter
Tableau des arguments de la fonction

La fonction et ses arguments peuvent être fournis soit par le biais d'alias, soit en ligne de commande.

Les alias peuvent contenir les clefs de cartographie d'arguments suivantes :

Nom	Description
:exec-fn	Symbole de fonction à utiliser si aucun n'est fourni en ligne de commande
:exec-args	Cartographie clef-valeur à inclure lors de l'exécution de exec-fn
:ns-default	Symbole d'espace de noms par défaut à utiliser lors de la résolution de exec-fn
:ns-aliases	Cartographie de symbole d'alias-symbole d'espace de noms à utiliser lors de la résolution de exec-fn

Si la fonction à appeler est définie dans un alias spécifié, elle est facultative sur la ligne de commande. Si son symbole est spécifié, il remplace `:exec-fn` dans les alias et est résolu en fonction de `:ns-default` et `:ns-aliases` dans les alias.

Les arguments `:exec-args` forment une carte de base qui est fusionnée avec les clefs, les valeurs et la carte kv finale sur la ligne de commande, dans cet ordre.

Les clefs sur la ligne de commande peuvent être des mots-clefs ou des chemins de clefs vectoriels (comme avec `assoc-in`) pour spécifier une clef imbriquée. Le dernier argument sur la ligne de commande est une carte finale facultative de clés et de valeurs. Consultez les sections suivantes sur les clefs, les chemins de clés et les guillemets pour plus de détails sur la manière de spécifier correctement les clés et les valeurs EDN.

Exécuter un outil (-T)

Les outils sont des fonctions externes au classpath du projet. L'exécution de fonctions d'outil avec l'option -T est identique à l'exécution de fonctions du projet avec l'option -X, à la différence que le classpath du projet n'est pas inclus :

clojure [clj-opt*] -T[name|aliases] a/fn [kpath v]* kv-map?

Lors de la construction du classpath pour l'outil, les dépendances et les chemins du projet ne sont pas inclus.

Les dépendances de l'outil sont incluses soit via ses alias, soit par son nom. Les outils peuvent être installés localement sous un nom court. Une fois installés, ils peuvent être utilisés dans n'importe quel projet disposant de la même configuration utilisateur. Consultez la section «Installation des outils» pour plus de détails.

Pour exécuter un outil par son nom, utilisez l'option `-Tnom_de_l'outil`, comme `-Tlinter`. Pour exécuter un outil par son ou ses alias, utilisez `-T:linter` (les alias sont toujours des mots-clefs).

Contrairement à l'option `-X`, une fonction d'outil DOIT être spécifiée sur la ligne de commande et ne peut pas être spécifiée dans l'alias de l'outil ni dans sa configuration d'installation. Sinon, les fonctions et les arguments de l'outil sont spécifiés de la même manière qu'avec l'option `-X`, que ce soit dans les alias ou sur la ligne de commande.

Exécuter un espace de noms ou un script principal (-M)

Vous pouvez utiliser l'option d'exécution -M pour appeler clojure.main, qui permet d'appeler un espace de noms avec une fonction -main ou un script Clojure :

clojure [clj-opt*] -M[aliases] [main-opts]

Les alias -M (si fournis) sont extraits de deps.edn et combinés pour former une carte d'arguments. La carte arg peut modifier le chemin de classe ou fournir :main-opts, un vecteur d'options principales de chaîne. Consultez la page clojure.main pour plus d'informations sur les options principales disponibles.

Utilisations courantes :

# exécuter une seule expression :
clojure -M -e '(+ 1 1)'

# exécutez l'espace de noms Clojure avec le point d'entrée principal :
clojure -M -m my.app

# exécuter un script Clojure autonome
clojure -M script.clj

Les options principales peuvent être fournies dans les alias avec la clef de cartographie arg :main-opts - lorsque les alias sont fusionnés, tous les :main-opts fournis remplacent ceux des alias précédents. Des options supplémentaires sur la ligne de commande après -M sont ajoutées à celles trouvées dans la carte d'arguments d'alias fusionnée.

Options

-Aaliases

-A prend un ou plusieurs alias concaténés, étant toujours des mots-clefs simples ou qualifiés, par ex. -A:test ou -A:test:perf/benchmark.

Bien que -A puisse être utilisé avec toutes les commandes d'exécution, c'est le seul exec opt pouvant être utilisé pour l'exécution de REPL, et c'est la raison la plus courante de son utilisation.

-X[aliases]

-X prend éventuellement un ou plusieurs alias concaténés, étant toujours des mots-clefs simples ou qualifiés, par ex. -X:test ou -X:test:perf/benchmark.

Le -X exec-opt indique l'exécution de la fonction, et tous les arguments après -X sont des arguments de la fonction en cours d'exécution, pas de la CLI. Tous les clj-opts (-S, -P,...) doivent être placés avant le -X dans la ligne de commande.

-Ttoolname, -T[aliases]

-T prend soit un nom d'outil (toujours des symboles, pas des mots-clefs), soit un ou plusieurs alias concaténés, étant toujours des mots-clefs simples ou qualifiés, par ex. -T:test ou -T:test:perf/benchmark.

Le -T exec-opt indique l'exécution de l'outil, et tous les arguments après -T sont des arguments de la fonction de l'outil, pas de la CLI. Tous les clj-opts (-S, -P, etc.) doivent être placés avant le -T dans la ligne de commande.

-M[aliases]

-M prend éventuellement un ou plusieurs alias concaténés, étant toujours des mots-clefs simples ou qualifiés, par ex. -M:test ou -M:test:perf/benchmark.

Le -M exec-opt indique l'exécution de clojure.main, et tous les arguments après -M sont interprétés par clojure.main. Tous les clj-opts (-S, -P,...) doivent être placés avant -M dans la ligne de commande.

-P

Utilisez -P avant l'un des autres exec-opts (-A, -X, -M, -T) pour effectuer une extension complète des dépôts, télécharger les dépôts et mettre en cache le chemin de classe, mais pas réellement exécuter la fonction, l'outil, le principal,...

-Jopt

Utilisez -J pour préfixer toute option JVM qui doit être fournie à votre programme (le -J sera supprimé). Par exemple, -J-Xmx1g ou -J-XX:+HeapDumpOnOutOfMemoryError. -J peut être utilisé avec tous les modes d'exécution qui exécutent un programme (repl, -X, -T, -M).

Consultez également les options JVM pour plus d'informations sur d'autres moyens de fournir des options JVM.

-Sdeps deps

Utilisez -Sdeps pour fournir des données deps.edn supplémentaires ou un chemin vers un fichier deps.edn sur la ligne de commande. Ceci est utilisé comme dernière source de dépôts dans la fusion. Les données deps devront être citées de manière appropriée pour la ligne de commande.

-Srepro

Utilisez -Srepro pour omettre l'utilisateur deps.edn des sources deps. Cela omet toute configuration spécifique à l'utilisateur pour garantir que la commande est reproductible pour d'autres.

Voir les sources des dépôts de Clojure

-Spath

Utilisez -Spath pour calculer et imprimer le chemin de classe.

-Stree

Utilisez -Stree pour calculer et afficher l'arborescence des dépendances. Voir la page d'extension des dépendances pour plus d'informations sur la sortie de l'impression de l'arborescence.

-Scp CP

Lorsque cette option est utilisée, le chemin de classe n'est pas calculé et le chemin de classe fourni est utilisé à la place. Ceci est surtout utile pour les tests ou le débogage. En général, vous devez laisser la CLI Clojure calculer (et mettre en cache) votre chemin de classe en fonction des paramètres deps.edn.

-Sforce

Cet indicateur marque le chemin de classe mis en cache existant (le cas échéant) comme étant obsolète. Le chemin de classe sera recalculé et mis en cache.

-Sverbose

Afficher les informations sur l'environnement et le chemin trouvées et utilisées par la CLI Clojure, principalement utiles pour déboguer l'emplacement de divers répertoires de configuration et de cache.

Cet indicateur ne modifie aucune autre exécution pouvant être spécifiée sur la ligne de commande, il peut donc être utilisé pour déboguer l'emplacement des fichiers cache pour une commande particulière.

-Sthreads N

Par défaut, l'expansion du dépôt se fera à l'aide d'un bassin de processus légers dimensionné en fonction du nombre de processeurs. Utilisez ce paramètre pour modifier le nombre de processus légers utilisés lors de l'expansion. La définition sur 1 effectuera une expansion en série avec un seul processus léger.

-Strace

L'arborescence de dépendances affichée par -Stree ou -X:deps tree contient souvent suffisamment d'informations pour déboguer pourquoi une bibliothèque ou une version de bibliothèque particulière a été sélectionnée. Cependant, si vous avez besoin de plus d'informations, cet indicateur imprime des informations beaucoup plus volumineuses dans un fichier trace.edn qui peut être utilisé lors du dépôt d'un problème sur tools.deps sur Ask Clojure.

--version, -version

Affiche la version Clojure CLI sur stdout (--version) ou stderr (-version). Notez que même si la version Clojure CLI détermine la version par défaut de Clojure utilisée lors de l'exécution, n'importe quelle version de la CLI peut utiliser n'importe quelle version de Clojure, et la version Clojure peut être définie dans les fichiers deps.edn pour modifier cette version.

Consultez la page de publication des outils pour plus d'informations sur la version et le journal des modifications.

--help, -h, -?

Afficher l'aide sur la console. Voir aussi le man clojure.

Alias

Lors de l'appel de commandes dans le contexte d'un projet, il est courant de devoir spécifier des données complexes difficiles à citer sur la ligne de commande. En tant que programmeurs Clojure, nous préférons fortement spécifier ces données dans la syntaxe Clojure (edn). Le format de fichier deps.edn nous permet de définir des données Clojure arbitraires et de donner un nom à ces données à l'aide d'alias. Les alias sont simplement des mots-clés qui nomment les données edn.

Chaque mode d'exécution de la CLI Clojure dispose de nombreuses options de configuration (la « arg map »). Ceux-ci peuvent être définis dans les cartes edn via des alias et sélectionnés sur la ligne de commande à l'aide des alias en -A, -X, -T ou -M. Vous trouverez ci-dessous une liste de toutes les clefs de cartographie d'arguments - sauf indication contraire, celles-ci sont valides dans tous les modes d'exécution.

Modificateurs de dépendance du projet

Nom	Description
:extra-deps	Carte de la bibliothèque vers les coordonnées devant être ajoutées aux dépôts racine
:override-deps	Carte de lib vers les coordonnées qui devraient remplacer deps dans la racine deps
:default-deps	Carte de lib vers les coordonnées qui doivent être utilisées si la coordonnée est nulle dans les dépôts racine ou transitifs

Modificateurs de chemin de classe

Nom	Description
:extra-paths	Vecteur de chemins de chaîne (ou d'alias de mots-clefs) à ajouter aux chemins de base
:classpath-overrides	Cartographie de lib vers le chemin de chaîne pour remplacer lib sur le chemin de classe

Dépôts et chemins d'outils (principalement utilisés par -T) :

Nom	Description
:replace-deps (synonyme : :deps)	Carte de la bibliothèque vers les coordonnées devant remplacer les deps du projet
:replace-paths (synonyme : :paths)	Vecteur de chaînes de chemin qui doivent remplacer les chemins du projet

Options JVM :

Nom	Description
:jvm-opts	Vecteur de chaînes à transmettre comme options jvm

Résolution de l'espace de noms (principalement utilisée par -X et -T)

Nom	Description
:ns-aliases	Cartographie du symbole d'alias au symbole d'espace de noms, utilisé pour résoudre les symboles (tels que :exec-fn)
:ns-default	Espace de noms par défaut pour les symboles non qualifiés (tels que :exec-fn)

Exécution de fonctions (-X et -T uniquement)

Nom	Description
:exec-fn	Fonction à exécuter avec -X
:exec-args	Arguments de fonction à transmettre à -X (peut être remplacé en ligne de commande)

Principal (-M uniquement) :

Nom	Description
:main-opts	Vecteur d'arguments de chaîne à transmettre à clojure.main

Lorsque plusieurs alias sont fournis, les clefs dans les cartographies d'arguments d'alias sont fusionnées avec la sémantique suivante (dans l'ordre spécifié dans les alias concaténés) :

:extra-deps - fusionner
:override-deps - fusionner
:default-deps - fusionner
:extra-paths - concaténés et distincts
:classpath-overrides - fusionner
:replace-deps / :deps - fusionner
:replace-paths / :paths - concaténé et distinct
:jvm-opts - concaténer
:ns-alias - fusionner
:ns-default - remplacer (dernières victoires)
:exec-fn - remplacer (dernières victoires)
:exec-args - fusionner si cartographier ou remplacer
:main-opts - remplacer (dernières victoires)

Utilisation d'alias à des fins personnalisées

Les clefs d'alias ci-dessus sont significatives pour l'exécution de Clojure CLI, mais vous pouvez définir des alias à n'importe quelle fin. Si vous créez un outil personnalisé qui nécessite une configuration, il est conseillé de définir des alias ou des clés d'alias bien connus avec un espace de noms à utiliser par votre outil. Veuillez vous abstenir d'ajouter des clés de niveau supérieur aux fichiers deps.edn - elles ne sont pas toujours disponibles via les outils de programmation.

Les programmes exécutés par la CLI Clojure reçoivent la base d'exécution pour l'exécution, y compris toutes les données d'alias. L'API clojure.java.basis ajoutée dans Clojure 1.12 peut être utilisée pour récupérer des données d'alias lors de l'exécution dans le programme.

Résolution de l'espace de noms

Les symboles dans les exec-opts ou arg maps (comme :exec-fn) sont résolus avec les règles suivantes :

Si la fonction n'est pas qualifiée, utilisez l'espace de noms dans la clef :ns-default dans la carte arg (s'il n'y en a pas, c'est une erreur)
Si la fonction est qualifiée et que le qualificatif est un alias dans le mappage d'arguments sous :ns-aliases, utilisez cet espace de noms
Sinon, utilisez le symbole de fonction pleinement qualifié

Dépendances

Chaque dépendance est définie au format deps.edn avec une lib et des coordonnées, plusieurs deps combinés dans une carte (les clés de carte alias arg utilisent le même format).

Sources deps.edn

La CLI Clojure construira la carte des chemins, des dépendances et des alias à utiliser en combinant jusqu'à quatre sources deps edn :

Root deps - défini comme une ressource intégrée dans la bibliothèque tools.deps, définit Clojure lui-même comme la seule dépendance (la version correspondra à la version Clojure CLI) et deux alias intégrés : :deps et :test. Deux référentiels Maven intégrés sont inclus : Maven central et Clojars.
User deps (facultatif) - un fichier deps.edn dans le répertoire de configuration utilisateur. Le fichier commence vide mais peut avoir une configuration supplémentaire et des outils définis pour plusieurs projets.
Project deps (facultatif) - le deps.edn dans le répertoire actuel (alias le répertoire du projet)
Extra deps (facultatif) - fournis sur la ligne de commande avec -Sdeps

Les sources deps sont fusionnées en un seul edn deps principal dans l'ordre indiqué ci-dessus, sauf :

-T tool execution - project :deps est supprimé et project :paths est remplacé par ["."]
-Srepro - user :deps est ignoré

La fusion est essentiellement une fusion avec une fusion, sauf pour :paths où seule la dernière source deps :paths est utilisée.

Classpath

Le chemin de classe JVM se compose d'une série de racines, soit des chemins de répertoire, soit des chemins d'accès aux fichiers jar. Les classes (et les fichiers Clojure) sont cartographiées via un paquet ou un espace de noms à un chemin relatif à la racine d'un chemin de classe. Par exemple, la classe java.lang.String peut être trouvée dans le chemin java/lang/String.class et l'espace de noms clojure.set Clojure peut être trouvé dans les chemins clojure/set.class (pour AOT), clojure/set.clj ou clojure/set.cljc. Lorsque la JVM doit charger l'un de ces fichiers, elle recherche le chemin relatif dans chaque racine et le charge une fois trouvé.

La CLI Clojure calculera un chemin de classe basé sur :

Sources deps.edn
Alias utilisés, en particulier les clefs de cartographie d'arguments liées aux chemins et aux dépôts
Modificateurs de ligne de commande tels que -Srepro et -Sdeps

En fin de compte, tous ces éléments se combinent en :

Chemins de projet
Deps (bibliothèques externes et leurs dépôts transitifs)

Chemins de projet

Une fois la fusion des arguments deps et d'alias effectuée, il existe des :paths from deps.edn et :extra-paths from alias. Ceux-ci sont tous deux constitués de vecteurs et l'ordre dans ces vecteurs est conservé. Les chemins supplémentaires sont toujours avant les chemins, de sorte que les alias peuvent remplacer les paramètres du projet.

Notez que les chemins du projet et les chemins supplémentaires sont résolus par rapport au répertoire actuel et doivent faire référence uniquement aux chemins à l'intérieur du projet, et non aux répertoires parents ou frères. Actuellement, faire référence à l'extérieur du projet émettra un avertissement, mais sa prise en charge est obsolète et sera supprimée à l'avenir (utilisez plutôt les dépôts locaux).

Expansion des dépendances

Une fois les dépôts fusionnés, il existe un ensemble de dépendances de niveau supérieur formant les racines du graphe de dépendances. Le graphique est exploré de haut en bas et chaque dépendance est développée tour à tour en utilisant les acheteurs appropriés (Maven. Git, local). Les cycles sont détectés et ne seront plus examinés.

Lorsque plusieurs versions de la même bibliothèque sont trouvées, un processus de sélection de version se produit. La page d'extension des dépendances contient plus de détails sur ce processus, mais généralement la version la plus récente d'une bibliothèque est utilisée. Toutefois, les versions de dépendance de niveau supérieur sont toujours utilisées sans modification : si vous devez spécifier une version spécifique ou résoudre un conflit, définissez la version dans une dépendance de niveau supérieur.

Les dépendances sont classées par profondeur de graphique à partir du haut et triées par ordre alphabétique par nom de bibliothèque à chaque niveau.

Pour plus d'informations sur les modificateurs de cartographie d'arguments tels que :extra-deps, :override-deps et :default-deps, consultez la page de référence deps.edn.

Construction du chemin de classe

Le chemin de classe contiendra :

Chemins supplémentaires (relatifs au projet), à déclarer dans le dernier alias pour les préciser
Chemins sources (relatifs au projet), dans l'ordre déclaré dans les dernières dépôts pour les préciser
Chemins de dépendance (généralement absolus) faisant référence à des fichiers JAR ou à des répertoires dans les emplacements de téléchargement appropriés

Les dépendances sont classées à partir du haut du graphique de dépendances en fonction de leur profondeur, puis triées par ordre alphabétique par nom de bibliothèque.

Les chemins de classe peuvent en outre être modifiés par la clef de cartographie arg :classpath-overrides (voir la référence deps.edn).

Vous pouvez afficher le chemin de classe calculé avec -Spath.

Propriétés de la JVM

Les propriétés JVM ont plusieurs sources :

Options codées en dur : -XX : -OmitStackTraceInFastThrow
Variable d'environnement $JAVA_OPTS
Clef de cartographie d'argument d'alias : jvm-opts (fusionnée entre les alias dans les dépôts principaux)
Options de ligne de commande -J

Toutes les options de ligne de commande JVM sont concaténées dans l'ordre ci-dessus. Dans la plupart des cas, les options JVM ultérieures sur la ligne de commande remplaceront tout paramètre précédent, mais dans tous les cas, la sémantique des options concaténées est celle de la JVM. Il n'y a pas de déduplication ni de remplacement d'options.

Commande CLI

Les commandes clj et clojure sont des scripts spécifiques à l'hôte qui :

Analyser les arguments CLI
(S'il n'est pas mis en cache), lancez une JVM pour calculer et mettre en cache le chemin de classe et d'autres configurations
Lancez une JVM pour exécuter le programme utilisateur comme spécifié par les options d'exécution -X, -T, -M

L'étape 2 est effectuée avec un uberjar faisant partie de l'installation de Clojure CLI - en général, vous ne contrôlez pas le chemin de classe ou la configuration de cette JVM (mais consultez les variables d'environnement pour certaines exceptions).

Java

Vous devez installer Java et le rendre disponible de plusieurs manières lorsque vous utilisez la CLI Clojure. Java 8 ou supérieur est requis. N'importe quelle distribution Java fonctionnera.

Java est trouvé en vérifiant les éléments suivants dans cet ordre :

Variable d'environnement $JAVA_CMD
java sur le $PATH
$JAVA_HOME/bin/java

S'il n'est pas trouvé, la CLI s'arrêtera avec un message d'erreur. Si clj -h se termine avec succès, un exécutable Java a été trouvé.

Répertoires et mise en cache

Il existe plusieurs répertoires importants utilisés par la CLI Clojure, cette section détaille comment ils sont calculés.

Répertoire du projet

Le répertoire du projet est le répertoire courant. Si le répertoire du projet contient un fichier deps.edn, celui-ci sera utilisé comme source deps du projet.

Il n'existe aucune option d'exécution dans le contexte d'un répertoire de projet distant.

Répertoire de configuration

Le répertoire de configuration contient :

Utilisateur utilisateur deps.edn
Répertoire de cache hors projet
Installations d'outils

Le répertoire de configuration est calculé comme suit:

Si $CLJ_CONFIG est défini, utilisez ce chemin
Si $XDG_CONFIG_HOME est défini, utilisez $XDG_CONFIG_HOME/clojure
Sinon, utilisez $HOME/.clojure

Si le répertoire de configuration n'existe pas, il sera créé et les fichiers suivants y seront copiés :

deps.edn - l'utilisateur par défaut deps.edn (essentiellement vide)
tools/tools.edn - l'outil intégré "tools" pour gérer les outils

Répertoire cache

Chaque exécution de la CLI utilise un répertoire de cache pour stocker le chemin de classe calculé et d'autres fichiers.

Le répertoire cache est calculé comme suit :

Si le répertoire courant a un projet deps.edn et que le répertoire courant est accessible en écriture, utilisez ./.cpcache
Sinon, utilisez le répertoire .cpcache dans le répertoire de configuration

Les fichiers du répertoire cache constituent un cache destiné à améliorer le temps de démarrage lors de l'utilisation d'un chemin de classe déjà calculé. En général, ce cache ne devrait jamais être obsolète, mais vous pouvez utiliser -Sforce pour forcer un recalcul sur une commande spécifique, ou simplement rm le répertoire du cache en cas de doute.

Lorsque vous installez une nouvelle version de la CLI, cela invalide parfois le cache (si le format de la clé de cache a changé), ce qui oblige les commandes que vous avez exécutées auparavant à recalculer le chemin de classe.

La CLI Clojure ne supprime jamais les fichiers dans les répertoires de cache, c'est donc à vous de décider si vous souhaitez nettoyer ces répertoires périodiquement. C'est une bonne pratique d'inclure .cpcache/ dans le fichier .gitignore de votre projet - rien n'est utile à partager avec d'autres utilisateurs du projet.

Variables d'environnement

Les variables d'environnement suivantes peuvent influencer l'exécution de la CLI (beaucoup sont décrites plus en détail ailleurs sur cette page) :

Variable	Description
CLJ_CONFIG	Répertoire de configuration utilisateur, utilisé pour entreposer l'utilisateur deps.edn, la configuration de l'outil et cpcache pour les commandes sans projet deps.edn (par défaut = ~/.clojure)
XDG_CONFIG_HOME	Si cette variable standard est définie, utilisera $XDG_CONFIG_HOME/clojure comme répertoire de configuration utilisateur
CLJ_CACHE	Répertoire de cache utilisateur, (par défaut = <config-dir>/.cpcache)
XDG_CACHE_HOME	Si cette variable standard est définie, utilisera $XDG_CACHE_HOME/clojure comme répertoire de cache utilisateur
CLJ_JVM_OPTS	Options JVM à inclure dans les appels internes au processus de création de chemin de classe, ce qui peut être utile pour fournir des éléments comme un magasin de clés certifiées avec un certificat auto-signé utilisé pour télécharger des artefacts internes
JAVA_CMD	Chemin d'accès à l'exécutable Java à utiliser
JAVA_HOME	S'il n'y a pas de $JAVA_CMD et pas de java sur le chemin, essaiera d'utiliser $JAVA_HOME/bin/java
JAVA_OPTS	Options JVM à inclure dans la commande utilisateur en cours d'exécution - non mises en cache. Inclus avant tout paramètre de ligne de commande -J et tout :jvm-opts
AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY et d'autres variables d'environnement AWS sont utilisées lors de l'accès aux dépôts Maven basés sur S3.
GITLIBS	Le chemin d'accès au répertoire de stockage gitlibs (par défaut = ~/.gitlibs)
GITLIBS_COMMAND	La commande git à exécuter (par défaut = git)
GITLIBS_DEBUG	Défini sur true pour imprimer toutes les commandes git en cours d'exécution
CLOJURE_CLI_ALLOW_HTTP_REPO	Défini sur true pour autoriser les URL du référentiel http:// (cela peut rendre vos téléchargements de dépendances sujets à des attaques de l'homme du milieu)

Clefs et chemins de clefs

Avec les options d'exécution -X ou -T, vous pouvez fournir des paires clef-chemin/valeur sur la ligne de commande. Le chemin de clé est soit une clef unique, soit un vecteur de clefs pour faire référence à une clé imbriquée (comme avec associ-in). Chaque chemin de clé sera utilisé pour s'associer à la carte :exec-args d'origine, en remplaçant la valeur qui s'y trouve.

# Remplacement de la touche supérieure
clj -X:my-fn :val 789

# Remplacement de clef imbriquée
clj -X:my-fn '[:my :data]' 789

En plus de transmettre des paires clef-chemin/valeur et des chemins de clef dans la ligne de commande, une carte facultative fournissant des cartographies de valeurs peut être transmise comme argument final. Cette carte fusionnera avec et peut-être remplacera les cartographies clef-chemin/valeur fournis précédemment :

# Augmente les arguments de my-fn
clj -X:a-tool my-fn :val 789 '{:val2 123}'

# Remplacer les arguments par my-fn
clj -X:a-tool my-fn :val 789 '{:val 123}'

# Une carte unique (pas de kvs) fournit des arguments à my-fn
clj -X:a-tool my-fn '{:val 789}'

Citation des clefs et des valeurs

Les clefs et les valeurs sur la ligne de commande sont lues comme edn. Les données suivantes peuvent être utilisées sans citer :

Nombres - 123, 12.4
Booléens - true, false
Nulle - nil
Symboles - name, foo/bar
Mots-clefs - :id, :company/name

Ces types de données doivent être entourés de guillemets simples :

Chaînes de caractères - '"salut"' - notez l'utilisation des guillemets simples pour l'interpréteur de commande et des guillemets doubles à lire comme une chaîne edn
Vecteurs - '[1 2 3]'
Cartes - '{:a 1, :b 2}'
Ensembles - '#{:a :b}'
Listes - '(1 2 3)'

Sous Windows, les interpréteurs de commandes WSL2 peuvent suivre les conseils ci-dessus, mais en utilisant clojure.exe, des guillemets d'échappement supplémentaires sont requis pour les valeurs de chaîne. Malheureusement, la combinaison des règles de citation pour la conversion des arguments du programme Windows en ligne de commande, la citation et le fractionnement de mots est très compliquée.

Pour transmettre une valeur de chaîne au niveau supérieur, si la valeur de chaîne ne contient pas d'espaces, vous pouvez utiliser '\"str\"'. Si la valeur de la chaîne contient des espaces (ou non), vous devez utiliser '"""str value"""'

PS D:> clj -X clojure.core/prn :string1 '\"no-spaces\"' :string2 '"""has spaces"""'
{:string1 "no-spaces", :string2 "has spaces"}

Pour les valeurs de chaîne imbriquées dans d'autres collections, utilisez des guillemets doubles s'il y a des espaces et des guillemets triples s'il n'y en a pas :

PS D:> clj -X clojure.core/prn :val '{:s1 """nospaces""" :s2 ""has spaces""}'
{:val {:s1 "nospaces", :s2 "has spaces"}}

Programmes

La CLI Clojure est conçue pour fournir un accès aux programmes (fonctions) d'autres bibliothèques avec leur propre chemin de classe indépendant. Cette capacité est exploitée pour fournir des fonctionnalités étendues via l'alias :deps intégré à la racine deps.edn, qui fournit le tools.deps.cli (voir API).

Liste des dépendances

clj -X:deps list

Affiche la liste triée de toutes les dépendances transitives sélectionnées pour le chemin de classe et les informations de licence (si trouvées). Des options supplémentaires peuvent être utilisées pour sélectionner des alias ou d'autres modifications de chemin de classe, ou pour modifier les informations d'impression.

Voir la documentation API.

Arbre de dépendance

clj -X:deps tree

Affiche l'arborescence des dépendances avec les informations d'inclusion/exclusion telles que déterminées lors de l'expansion des dépendances). Des options supplémentaires peuvent être utilisées pour sélectionner des alias ou d'autres modifications de chemin de classe, ou pour modifier les informations d'affichage.

Par exemple, ce qui suit peut être utilisé pour imprimer l'arborescence deps pour un alias :test :

clj -X:deps tree :aliases '[:test]`

Voir la documentation API.

Liste d'alias

clj -X:deps aliases

Ce programme affiche tous les alias disponibles sur la ligne de commande en fonction de l'environnement deps actuel. Des options supplémentaires peuvent être utilisées pour sélectionner des alias ou d'autres modifications de chemin de classe.

Voir la documentation API.

Fonctions d'aide

Les fonctions help/doc et help/dir examinent comment un outil peut être utilisé. Étant donné que l'alias :deps n'inclut pas le chemin de classe du projet, ceux-ci ne sont actuellement pas utiles lors de l'exécution de fonctions dans votre propre projet.

-X:deps help/doc - affiche les chaînes de documentation et les listes de paramètres des fonctions données avec la clef :ns ou la fonction spécifiée par une clef supplémentaire :fn ; si aucun des deux n'est donné, alors :ns-default est utilisé
-X:deps help/dir - affiche les fonctions publiques dans l'espace de noms fourni avec la clef :ns ou :ns-default si elle n'est pas donnée

Exemple de liste de l'ensemble des fonctions dans :ns-default pour l'outil outils intégrés :

clojure -A:deps -Ttools help/dir

Exemple pour lister l'ensemble des fonctions dans un alias :

clojure -X:deps:my-alias help/dir

Affichez les docstrings pour l'espace de noms d'aide lui-même (notez que l'aide est définie dans la carte :ns-aliases pour :deps) :

clojure -X:deps help/doc :ns help

Voir : documentation sur l'API

Bibliothèques de préparation

Les bibliothèques sources avec la source Clojure peuvent être immédiatement ajoutées au chemin de classe d'un projet qui l'utilise. Cependant, certaines bibliothèques sources nécessitent une certaine préparation avant de pouvoir être ajoutées, par exemple en raison de la nécessité d'une compilation Java, ou de la copie/remplacement de fichiers de ressources, etc. La CLI Clojure détectera désormais les projets nécessitant une préparation et empêchera l'exécution du programme à partir de la source à moins que l'étape de préparation ne soit terminée.

Si votre bibliothèque a besoin d'une préparation, ajoutez la clef :deps/prep-lib à votre deps.edn :



{:paths ["src" "target/classes"]

 :deps/prep-lib

 {:ensure "target/classes"

  :alias :build

  :fn compile-java}}

Les clefs sous :deps/prep-lib sont :

Clef	Description
:ensure	L'existence du répertoire détermine si une préparation est nécessaire (si elle existe, la préparation a été effectuée)
:alias	Alias à invoquer avec -T pendant la préparation
:fn	Fonction à appeler avec -T pendant la préparation

Ainsi, le fichier deps.edn doit également contenir un alias permettant d'exécuter la fonction spécifiée. Consultez le guide tools.build pour savoir comment utiliser tools.build afin de définir un script de compilation avec une fonction invocable.

Si vous ajoutez cette bibliothèque Git comme dépendance et tentez d'exécuter un programme, l'interface de ligne de commande Clojure la téléchargera, détectera qu'elle nécessite une préparation et qu'elle n'a pas été préparée (le chemin « target/classes » est introuvable), puis s'arrêtera.

Pour trouver et préparer les bibliothèques dans l'arborescence des dépendances, vous pouvez utiliser l'outil prep fourni avec l'alias intégré :deps:

clj -X:deps prep

La tâche de préparation recherche toutes les bibliothèques dans l'expansion des dépendances et identifie celles qui sont des bibliothèques sources, celles qui nécessitent une préparation (d'après leur clé `:deps/prep-lib`) et celles qui ne sont pas encore préparées (d'après le répertoire `:ensure` dans leur table `:deps/prep-lib`). Ces bibliothèques exécuteront la commande spécifiée par alias et fonction, comme ceci : `clj -T:<alias> <fn>`.

Une fois préparée, une bibliothèque n'a plus besoin d'être préparée par les autres utilisateurs de cette version de la bibliothèque Git.

Faut-il utiliser une étape de préparation qui compile votre code Clojure ? Généralement, non. Tous les utilisateurs de cette bibliothèque Git sur une même machine partageront le classpath préparé par l'étape de préparation. Il est préférable de laisser le choix du compilateur Clojure et des bibliothèques dépendantes à chaque application utilisant cette bibliothèque. Pour plus d'informations sur la compilation en mode développement, consultez le guide «Démarrage en mode développement».

Voir : Documentation de l'API.

Recherche de versions

Pour rechercher les versions disponibles d'une bibliothèque Maven ou Git, utilisez l'outil `find-versions` fourni avec l'alias intégré `:deps`.

clj -X:deps find-versions ...

Les paramètres pouvant être fournis sont :

Paramètre	Description
:lib	Nom de la bibliothèque Git ou Maven. L'URL Git sera automatiquement construite à partir du nom de la bibliothèque. Par exemple, `:git/lib io.github.clojure/tools.deps.graph` générera l'URL `https://github.com/clojure/tools.deps.graph.git`. Pour Maven, utilisez le nom de la bibliothèque, par exemple `org.clojure/tools.deps.graph`.
:tool	Nom de l'outil s'il est déjà installé.

La commande `find-versions` affichera les coordonnées Git ou Maven, une par ligne, dans la console.

Voir : documentation de l'API.

Installation Maven locale

Le programme `mvn-install` (avec l'option `-X:deps`) est fourni avec l'interface de ligne de commande Clojure pour plus de simplicité et peut être exécuté avec l'option `-X` pour installer un fichier JAR dans votre cache Maven local.

Les paramètres d'installation incluent les options suivantes :

Required:
:jar - path to jar file, use pom inside jar by default

To supply an explicit pom file:
:pom - path to pom file (used instead of pom inside the jar)

To generate a minimal pom file:
:lib - qualified symbol like my.org/lib
:version - string
:classifier - string

Other options:
:local-repo - path to local repo (default = ~/.m2/repository)

Vous pouvez passer des valeurs de remplacement sur la ligne de commande pour ces éléments, selon vos besoins :

clj -X:deps mvn-install :jar '"/path/to.jar"'

Comme indiqué précédemment, les chaînes edn doivent être placées entre guillemets doubles, puis entre guillemets simples pour l'interpréteur de commandes.

Un fichier pom doit être fourni explicitement, généré à partir de :lib/:version, ou inclus dans le fichier .jar (par défaut).

Voir : Documentation de l'API

Générer un fichier pom.xml Maven

Utilisez le programme suivant pour générer ou mettre à jour un fichier pom.xml existant avec les dépendances et les chemins de votre projet :

-X:deps mvn-pom - Générer (ou mettre à jour un fichier pom.xml existant) avec les dépendances et les chemins d'accès

Voir la documentation de l'API

Outils

Un outil est un ensemble de fonctions fournies dans une bibliothèque. Les fonctions d'un outil s'exécutent dans un processus distinct, avec son propre classpath, indépendant de celui du projet. Elles prennent un seul argument de type carte et sont invoquées avec l'option `-T` (syntaxe identique à celle de l'option `-X`).

Les outils sont décrits soit par un alias (partageable par les autres utilisateurs du projet), soit par un nom d'outil local installé sur votre machine (partageable entre projets).

Installation des outils

Un outil de gestion des outils est automatiquement installé par l'interface de ligne de commande Clojure (CLI) sous le nom «tools». Il propose plusieurs fonctions utiles :

Fonction	Description
install	Installe ou réinstalle un outil.
install-latest	Installe ou réinstalle la dernière version d'un outil.
list	Liste tous les outils installés.
remove	Supprime un outil installé.
show	Affiche les informations et l'utilisation d'un outil.

install

Une fois que vous avez déterminé la version de l'outil à installer, utilisez la fonction d'installation pour installer l'outil par son nom.

clj -Ttools install ...

Les arguments de l'outil d'installation sont :

Argument	Description
lib	Val est une table de coordonnées, conformément à deps.edn.
:as	Nom de l'outil, sera utilisé pour les appels ultérieurs.

Par exemple :

clj -Ttools install io.github.clojure/tools.deps.graph '{:git/tag "v1.0.63"}' :as deps-graph

Sous Windows, des guillemets d'échappement supplémentaires sont nécessaires :

clj -Ttools install io.github.clojure/tools.deps.graph '{:git/tag """v1.0.63"""}' :as deps-graph

Notez que les dépendances Git peuvent être entièrement décrites lors de l'installation de l'outil avec uniquement le nom de la bibliothèque Git (utilisé par convention pour former une URL Git) et une étiquette Git. Alternativement, les coordonnées peuvent contenir explicitement :git/url ou :git/sha.

install-latest

Pour trouver et installer la dernière version d'un outil en une seule étape :

clj -Ttools install-latest :lib io.github.clojure/tools.deps.graph :as deps-graph

Pour mettre à jour un outil existant vers la dernière version, vous pouvez également spécifier l'outil par son nom :

clj -Ttools install-latest :tool deps-graph

list

Pour lister tous les outils installés :

clj -Ttools list

Pour supprimer un outil installé :

clj -Ttools remove :tool name

Bonnes pratiques pour les développeurs d'outils

Bonnes pratiques :

Fournissez votre outil sous forme de bibliothèque Git publique.
Définissez l'API de votre outil dans un ou plusieurs espaces de noms Clojure, sous forme de fonctions prenant une map en argument.
Créez une clef `:tools/usage` à la racine de votre fichier `deps.edn`, avec une clé `:ns-default` et/ou `:ns-aliases` pour vos espaces de noms d'API.
Étiquetez votre dépôt Git pour créer une version, en utilisant un système de numérotation clair pour les utilisateurs. Une convention courante consiste à utiliser des chaînes de version comme «v1.2.3».

Les outils peuvent fournir les instructions suivantes aux utilisateurs :

Rechercher les versions d'un outil : `clj -X:deps find-versions :lib io.github.USER/TOOL`
Installer l'outil : `clj -Ttools install io.github.USER/TOOL '{:git/tag "VERSION"}' :as NAME`
Lancer l'outil : `clj -TNAME f args...`

Protocole d'exécution de fonction

Certains outils fournissent des fonctions conçues pour être exécutées par un autre processus, sous réserve des contraintes et attentes suivantes :

La fonction doit prendre un seul argument de type map.
Les résultats sont renvoyés par la fonction (comme d'habitude).
Les exceptions levées par la fonction entraînent un échec et les données de l'exception (de type Throwable→map) sont transmises au processus externe, qui la relance dans un message d'information d'exception (ex-info).
Les résultats d'affichage ne sont pas capturés (par défaut).
Tout résultat ou donnée d'exception doit pouvoir être affiché et relu sans risque dans un autre processus.

Plusieurs clefs de la table d'arguments revêtent une importance particulière pour l'interface de ligne de commande Clojure (CLI) lors des options `-X` ou `-T`. Toutes ces clefs seront supprimées de la table d'arguments avant l'appel de la fonction :

Nom	Description
:clojure.exec/invoke	`:fn` pour utiliser ce protocole
:clojure.exec/out	`:capture` pour capturer et renvoyer la sortie standard (stdout) pendant l'exécution de la fonction
:clojure.exec/err	`:capture` pour capturer et renvoyer la sortie d'erreur (stderr) pendant l'exécution de la fonction

Le résultat est encapsulé dans une carte d'enveloppe affichée avec les clefs suivantes et renvoyé via la sortie standard de l'interface de ligne de commande :

Clef	Description
:tag	:ret ou :err selon que la fonction a renvoyé un résultat ou levé une exception
:val	Valeur de retour ou données d'exception, converties en chaîne de caractères
:out	Sortie standard capturée (si demandée)
:err	Sortie d'erreur capturée (si demandée)
:ms	Temps d'exécution de la fonction en millisecondes

Une API consommateur pour ce protocole est fournie depuis Clojure 1.12.0-alpha2.

Les fournisseurs de dépendances

Les coordonnées de dépendance sont interprétées par les fournisseurs de dépendances, qui reconnaissent un type de coordonnée particulier et savent comment trouver les dépendances et télécharger les artefacts d'une bibliothèque. L'interface de ligne de commande Clojure prend actuellement en charge les fournisseurs de dépendances suivants : Maven, Git et local (qui inclut les répertoires et les fichiers JAR). La bibliothèque sous-jacente tools.deps prend en charge les extensions de fournisseur de dépendances lorsqu'elle est utilisée comme bibliothèque.

Les attributs de coordonnée déterminent le fournisseur de dépendances utilisé. En général, la plupart des attributs de fournisseur de dépendances sont qualifiés par type de fournisseur (avec quelques exceptions). Les attributs de coordonnée indépendants du fournisseur de dépendances utilisent le qualificateur deps.

Certains fournisseurs de dépendances peuvent également rechercher des attributs de configuration à la racine du fichier de configuration deps.edn en utilisant le même qualificateur.

Maven

Le fournisseur Maven utilise le qualificateur `mvn` pour récupérer les artefacts de bibliothèque depuis les dépôts Maven, le gestionnaire de dépôts standard de l'écosystème Java. Les bibliothèques sont téléchargées sous forme de fichiers `.jar` et stockées dans le cache local du dépôt Maven (situé par défaut dans `~/.m2/repository`). D'autres outils JVM peuvent également utiliser ce cache.

Consultez la documentation de `deps.edn` pour plus de détails sur le type de coordonnées Maven et la configuration du fournisseur Maven.

Dépôts Maven authentifiés

Pour les dépendances Maven dans les dépôts authentifiés, l'infrastructure Maven existante est utilisée pour transmettre les informations d'identification.

Dans votre fichier `~/.m2/settings.xml` :


<settings>

  ...

  <servers>

    <server>

      <id>my-auth-repo</id>

      <username>zango</username>

      <password>123</password>

    </server>

    ...

  </servers>

  ...

</settings>

Ensuite, dans votre fichier deps.edn, incluez un dépôt dont le nom correspond à l'identifiant du serveur (ici, my-auth-repo) :



{:deps

 {authenticated/dep {:mvn/version "1.2.3"}}

 :mvn/repos

 {"my-auth-repo" {:url "https://my.auth.com/repo"}}}

Il vous suffit ensuite de faire référence à vos dépendances comme d'habitude dans la directive `:deps`.

Dépôts Maven S3

Le proxy Maven (mvn) prend également en charge la connexion aux dépôts Maven publics et privés hébergés sur AWS S3. Ceci est particulièrement utile pour accéder à des dépôts Maven privés depuis une application hébergée sur AWS.

Ajoutez une directive `:mvn/repos` incluant la racine du dépôt S3 :



{:deps

 {my/library {:mvn/version "0.1.2"}}

 :mvn/repos

 {"my-private-repo" {:url "s3://my-bucket/maven/releases"}}}

Les compartiments S3 sont spécifiques à la région AWS dans laquelle ils ont été créés. Le transporteur S3 tentera de déterminer l'emplacement du compartiment. Si cela ne fonctionne pas, vous pouvez spécifier explicitement la région du compartiment dans l'URL : «s3://my-bucket/maven/releases?region=us-west-2».

Pour les dépôts authentifiés, les informations d'identification AWS peuvent être configurées dans le fichier ~/.m2/settings.xml pour chaque serveur ou seront chargées automatiquement à partir de la chaîne d'informations d'identification AWS (variables d'environnement, etc.). Le nom du dépôt dans deps.edn doit correspondre à l'ID du serveur dans settings.xml :



<settings>

  ...

  <servers>

    <server>

      <id>my-private-repo</id>

      <username>AWS_ACCESS_KEY_HERE</username>

      <password>AWS_SECRET_ACCESS_KEY_HERE</password>

    </server>

    ...

  </servers>

  ...

</settings>

Les informations d'identification AWS S3 peuvent être configurées dans l'environnement à l'aide de l'une des méthodes suivantes :

Définissez les variables d'environnement AWS_ACCESS_KEY_ID et AWS_SECRET_ACCESS_KEY.
Créez un profil par défaut dans le fichier d'informations d'identification AWS ~/.aws/credentials (l'ancien fichier ~/.aws/config est également pris en charge).
Créez un profil nommé dans le fichier d'informations d'identification AWS et définissez la variable d'environnement AWS_PROFILE avec son nom.
Les informations d'identification des profils de conteneurs et d'instances Amazon ECS devraient également fonctionner, mais n'ont pas été testées.

Pour plus d'informations, la plupart des conseils de ce document AWS expliquent comment localiser les informations d'identification. Notez cependant que les options des propriétés système Java ne fonctionnent pas avec l'interface de ligne de commande Clojure (mais fonctionnent si vous utilisez directement la bibliothèque tools.deps).

Proxies Maven

Dans les environnements où l'accès à Internet se fait via un proxy, la configuration Maven existante dans ~/.m2/settings.xml est utilisée pour établir la connexion au proxy :


<settings>

  ...

  <proxies>

    <proxy>

      <id>my-proxy</id>

      <host>proxy.my.org</host>

      <port>3128</port>

      <nonProxyHosts>localhost|*.my.org</nonProxyHosts>

    </proxy>

  </proxies>

  ...

</settings>

Pour plus de détails, consultez le guide Maven sur l'utilisation des proxys.

En-têtes HTTP Maven

Pour ajouter des en-têtes personnalisés aux requêtes HTTP sortantes, la configuration Maven existante dans ~/.m2/settings.xml est utilisée :


<settings>

  ...

  <servers>

    <server>

      <id>my-token-repo</id>

      <configuration>

        <httpHeaders>

          <property>

            <name>Private-Token</name>

            <value>abc123</value>

          </property>

        </httpHeaders>

      </configuration>

    </server>

    ...

  </servers>

  ...

</settings>

L'identifiant du serveur dans settings.xml doit correspondre au nom du dépôt dans deps.edn :



{:mvn/repos

 {"my-token-repo" {:url "https://my.auth.com/repo"}}}

Ce mécanisme est utilisé par les dépôts qui s'authentifient à l'aide d'un jeton plutôt que par nom d'utilisateur et mot de passe.

Git

Le module d'acquisition Git prend en charge l'utilisation directe des bibliothèques sources hébergées dans des dépôts Git. Par défaut, les bibliothèques Git sont téléchargées dans le répertoire ~/.gitlibs. L'arborescence de travail est extraite et mise en cache pour chaque SHA inclus comme dépendance.

Pour plus de détails sur le type de coordonnées Git, consultez la documentation deps.edn.

Configuration et débogage

Le module `git procurator` permet d'accéder à git en ligne de commande (et à ssh). git 2.5 ou une version supérieure est requise. En général, si l'accès fonctionne en ligne de commande, il devrait également fonctionner via l'interface de ligne de commande Clojure. Git doit être installé et, par défaut, inclus dans le PATH. Pour l'accès SSH, consultez la documentation de votre système (généralement, vous enregistrerez vos clés SSH dans `~/.ssh/id_rsa`).

Les variables d'environnement suivantes peuvent être configurées pour contrôler l'utilisation de git :

Variable	Description
GITLIBS	Chemin vers le répertoire de stockage des bibliothèques Git (par défaut : `~/.gitlibs`)
GITLIBS_COMMAND	Commande à exécuter pour accéder à git (par défaut : `git`)
GITLIBS_DEBUG	Définir sur `true` pour afficher un journal des commandes git exécutées et de leur sortie (par défaut : `false`)

Local

Le fournisseur local inclut les répertoires locaux ou les fichiers JAR comme dépendance. Consultez la documentation deps.edn pour plus de détails sur le type de coordonnées locales.

Glossaire

Artefact

Une bibliothèque distribuée dans un fichier conteneur, capturant l'état de la bibliothèque à un instant donné, ayant éventuellement subi un processus de compilation, étiquetée avec un numéro de version, contenant un manifeste documentant ses dépendances et empaquetée, par exemple, dans un fichier JAR.

Bibliothèque

Une bibliothèque est un ensemble de code Clojure (ou autre) qui résout un problème et étant géré sous un répertoire racine unique. Dans la plupart des cas (mais ce n'est pas exclusif), les dépôts GitHub contiennent une seule bibliothèque. Chaque bibliothèque possède un nom distinct, associé à un espace de noms ; dans Maven, ce nom est déterminé par l'identifiant de groupe/l'identifiant d'artefact.

Chemin de classe (et racines/chemins)

Liste ordonnée des emplacements locaux (répertoires du système de fichiers et/ou fichiers JAR) constituant les chemins racines pour la

Conflit de versions

Un conflit de versions survient lorsque l'extension de dépendance contient la même bibliothèque avec plusieurs versions, empêchant ainsi le choix automatique de la version optimale :

Rupture de version semver (changement de version majeure)
Identifiants SHA GitHub sans racine ni ancêtre communs (par exemple, deux identifiants SHA sur des branches différentes ou des dépôts non liés)
Versions couvrant différents dépôts ou types de dépôts, rendant impossible l'établissement d'une relation de parenté.

Coordonnées

Une version particulière d'une bibliothèque, choisie pour être utilisée, avec les informations suffisantes pour l'obtenir et l'utiliser.

Dépendance

Une expression, au niveau du projet/de la bibliothèque, indiquant que la bibliothèque déclarante a besoin de la bibliothèque déclarée pour fournir certaines de ses fonctions. Doit au moins spécifier le nom de la bibliothèque ; peut également spécifier la version et d'autres attributs. Les dépendances fonctionnelles sont plus précises.

Types de dépendances :

Artefacts Maven (approche par artefacts)
Bibliothèques Git (approche par code source)
Bibliothèque locale (approche par code source) : un répertoire local
Artefact local (approche par artefacts) : un fichier JAR local

recherche des dépendances (require/import) à l'exécution. Ce chemin est fourni comme argument à Java, qui en contrôle la sémantique. Nous déconseillons les dépendances d'ordre dans le chemin de classe, car cela implique la duplication d'un espace de noms ou d'un fichier de ressources (et donc un risque de dysfonctionnement).

Dépôt Maven

Un dépôt d'artefacts de bibliothèque, par exemple Maven Central ou Clojars.

Différence de version

Ce problème survient lorsque l'extension de dépendance contient la même bibliothèque avec plusieurs versions spécifiées, mais avec un ordre relatif (par numéro, SHA, etc.). Les différences de version peuvent être résolues en choisissant la version la plus récente ou la plus récente, lorsque cette relation est possible.

Expansion

Étant donné un ensemble de dépendances racines, fermeture complète de l'ensemble des dépendances transitives.

Résolution

Étant donné un ensemble de dépendances racines et des modifications supplémentaires, crée un arbre de dépendances entièrement développé, puis génère une correspondance entre chaque bibliothèque mentionnée et une version unique à utiliser qui satisfait toutes les dépendances, ainsi que le chemin local vers cette source ou cet artefact. Les dépendances de chaque entrée sont également incluses. Les conflits surviennent uniquement si des bibliothèques dépendent de versions majeures différentes d'une même bibliothèque.

Version

Un système de numérotation dont l'interprétation est déterminée par convention, souvent au format x.y.z. Un système courant est le «versionnage sémantique» (ou «semver»), qui attribue une signification aux changements à chaque niveau ; par exemple, un changement du premier numéro majeur indique une modification incompatible.

Dernière mise à jour : Lundi, le 2 février 2026