Crayons.jl

Autre code source

v4.1.1

Télécharger

Chaînes colorées et stylisées pour terminaux.

Crayons est un package qui facilite l'écriture de chaînes de différentes couleurs et styles sur les terminaux. Il prend en charge les 16 couleurs du système, les extensions de couleurs réelles 256 couleurs et 24 bits, ainsi que les différents styles de texte disponibles pour les terminaux. Le package est conçu pour fonctionner correctement, sans dépendances et se charge rapidement (temps de chargement d'environ 10 ms après précompilation).

Installation

 import Pkg; Pkg . add ( " Crayons " )

Usage

Créer `Crayon`

Un Crayon est créé avec le mot clé constructeur uniquement :

 Crayon (foreground,
       background,
       reset,
       bold,
       faint,
       italics,
       underline,
       blink,
       negative,
       conceal,
       strikethrough)

L’argument foreground et background peut être de trois types :

Un Symbol représentant une couleur. Les couleurs disponibles sont black , red , green , yellow , blue , magenta , cyan , light_gray , default , dark_gray , light_red , light_green , le light_yellow , le bleu light_blue , light_magenta , light_cyan et white . Pour voir les couleurs en action, essayez Crayons.test_system_colors() . Ces couleurs sont prises en charge par presque tous les terminaux.
Un Integer compris entre 0 et 255. Cela utilisera les codes d’échappement ANSI à 256 couleurs. Pour voir quel numéro correspond à quelle couleur et si votre terminal prend en charge 256 couleurs, utilisez Crayons.test_256_colors(codes=true) .
Un Tuple de trois Integer s, tous compris entre 0 et 255. Ceci sera interprété comme une couleur (r, g, b) 24 bits. Pour tester la prise en charge de vos terminaux pour les couleurs 24 bits, utilisez Crayons.test_24bit_colors(codes=false) . La prise en charge est actuellement assez limitée mais est continuellement améliorée dans les terminaux, voir ici.
Un UInt32 représentant une couleur donnée au format hexadécimal. Sera converti au format RVB correspondant.

Les autres arguments du mot clé sont tous de type Bool et déterminent si le style correspondant doit être explicitement activé ou désactivé :

reset - réinitialiser tous les styles et couleurs par défaut
bold — texte en gras, éclaircit également les couleurs sur certains terminaux
faint — texte pâle, peu pris en charge
italics — texte en italique, peu pris en charge
underline — texte souligné
blink — texte clignotant
negative : échangez le premier plan et l'arrière-plan
conceal - masque le texte, peu pris en charge
strikethrough : ligne horizontale passant au milieu du texte, peu répandue.

Pour voir le texte avec les différents styles actifs, utilisez Crayons.test_styles()

En n'utilisant nothing pour aucun des arguments de mot-clé, cette couleur ou ce style est inactif et n'est donc ni activement activé ni désactivé.

Pour plus de commodité, Crayon pour la version premier plan/arrière-plan des 16 couleurs système ainsi que les différents styles sont pré-faits et se trouvent dans le module Crayons.Box . Elles portent le nom <COLOR_NAME>_<BG/FG> pour les couleurs de premier plan/arrière-plan et <STYLE> pour les différents styles (notez les majuscules). L'appel using sur le module Crayons.Box amènera tout cela dans une portée globale.

Macros de chaînes

Crayon peuvent également être créés de manière plus concise à l'aide du crayon macro à chaîne. Ceux-ci sont écrits en utilisant crayon"[[fg:]<col>] [bg:<col>] ([[!]<style>] ...)" où :

le texte entre crochets est facultatif
<col> est une couleur donnée sous la forme d'un nombre hexadécimal, d'un tuple (r,g,b) (sans espaces), d'un nombre compris entre 0 et 255 ou de l'une des 16 couleurs nommées.
<style> est l'un des styles.
! signifie que le style est explicitement désactivé.
(<style> ...) signifie un nombre répété de styles, séparés par des espaces.

Quelques exemples d'utilisation des macros de chaîne et du constructeur équivalent sont présentés ci-dessous

 crayon " red " # Crayon(foreground = :red)
crayon " bg:(255,0,255) " # Crayon(background = (255, 0, 255))
crayon " !bold underline 0xff00ff " # Crayon(bold = false, underline = true, foreground = 0xff00ff)
crayon " #0000ff " # Crayon(foreground = 0x0000ff)

Utiliser les `Crayon`

Le processus d’impression de texte coloré et stylisé à l’aide de crayons est simple. En imprimant un Crayon sur le terminal, les séquences de codes correctes sont envoyées au terminal de telle sorte que le texte imprimé ultérieur prenne la couleur et le style du Crayon imprimé. Par exemple, essayez d'exécuter le code ci-dessous dans le REPL :

 print ( Crayon (foreground = :red ), " In red. " , Crayon (bold = true ), " Red and bold " )
print ( Crayon (foreground = 208 , background = :red , bold = true ), " Orange bold on red " )
print ( Crayon (negative = true , underline = true , bold = true ), " Underlined inverse bold " )
print ( Crayon (foreground = ( 100 , 100 , 255 ), background = ( 255 , 255 , 0 )), " Bluish on yellow " )

using Crayons . Box
print (GREEN_FG, " This is in green " )
print (BOLD, GREEN_FG, BLUE_BG, " Bold green on blue " )

Il est également possible d'utiliser la surcharge d'appels sur Crayon s créés. Le Crayon peut être appelé avec des ficelles et d'autres Crayon et les couleurs et les styles s'emboîteront correctement. Les séquences de fin correctes seront également imprimées afin que les couleurs et les styles soient désactivés en dehors de la portée de l'appel. Cette fonctionnalité est peut-être illustrée plus clairement avec quelques exemples :

 using Crayons . Box
print ( UNDERLINE ( " This is underlined. " ), " But this is not " )
print ( RED_FG ( " Hello " , BLUE_BG ( " world " ), " !!! " ), " !!! " )
print ( GREEN_BG ( " We " ,
          UNDERLINE ( " are " ,
              MAGENTA_FG ( " nesting " ),
          " some " ),
      " colors " )
     )

Remarque : Pour que les séquences de couleurs soient imprimées, les couleurs de Julia REPL doivent être activées, soit par Julia détectant automatiquement la prise en charge du terminal, soit en démarrant Julia avec l'argument --color=yes . Alternativement, si la variable d'environnement FORCE_COLOR existe ou si Crayons.force_color(::Bool) a été activée, les séquences de couleurs sont imprimées quoi qu'il arrive. De plus, étant donné que relativement peu de terminaux prennent en charge les couleurs 24 bits complètes, il est possible d'activer le mode 256 couleurs qui convertit le crayon 24 bits en un crayon 256 couleurs lors de l'impression. Cela se fait soit en définissant l'environnement variable FORCE_256_COLORS , soit en appelant Crayons.force_256_colors(::Bool) . De plus, certains systèmes ont des problèmes même avec 256 couleurs, il est possible de convertir vers une des 16 couleurs système en définissant la variable FORCE_SYSTEM_COLORS ou en appelant Crayons.force_system_colors(::Bool) . Notez que 16 couleurs (versions 8 + 8 lumières) constituent un espace colorimétrique assez petit, il est donc peu probable que la conversion soit très bonne.

Fusionner `Crayon`

Deux ou plusieurs Crayon peuvent être fusionnés, ce qui donne un nouveau Crayon avec toutes les propriétés de ceux fusionnés. Cela se fait avec la fonction merge(crayons::Crayon...) ou en multipliant Crayon s à l'aide de * . Si deux Crayon spécifient la même propriété, alors la propriété du dernier Crayon de la liste d'arguments est utilisée :

 using Crayons . Box
r_fg = Crayon (foreground = :red )
g_bg = Crayon (background = :green )
merged = merge (r_fg, g_bg)
print (merged, " Red foreground on green background! " )
print (r_fg * g_bg * Crayons . Box . BOLD, " Bold Red foreground on green background! " )
# Also with call overloading and nesting
print ( GREEN_FG (
          " I am a green line " ,
          BOLD * BLUE_FG * UNDERLINE (
              " with a bold underlined blue substring "
          ),
          " that becomes green again! "
     ))

Divers

La fonction inv sur un Crayon renvoie un Crayon qui annule ce que fait le Crayon dans l'argument de inv . À titre d'exemple, inv(Crayon(bold = true)) renvoie un Crayon qui désactive le gras.

Imbrication avancée de couleurs et de styles

Si vous souhaitez imbriquer des couleurs et des styles via des appels de fonction, il existe le type CrayonStack . push! Crayon sur la pile, imprimez le texte sur la pile, puis pop! les Crayons . La pile gardera une trace du Crayon actuellement actif. Il s'utilise comme un Crayon :

stack = CrayonStack ()
print (stack, " normal text " )
print ( push! (stack, Crayon (foreground = :red )), " in red " )
print ( push! (stack, Crayon (foreground = :blue )), " in blue " )
print ( pop! (stack), " in red again " )
print ( pop! (stack), " normal text " )

Un CrayonStack peut également être créé en mode incremental en appelant CrayonStack(incremental = true) . Dans ce cas, CrayonStack imprimera uniquement les modifications nécessaires pour passer de l'état de texte précédent au nouvel état, ce qui entraînera l'impression de moins de codes de couleur. Cependant, notez que cela signifie que le CrayonStack doit être imprimé dans le tampon de sortie pour toutes les modifications qui y sont apportées (c'est-à-dire à la fois lorsque push! et pop! sont utilisés). L'exemple ci-dessous montre un exemple fonctionnel où toutes les modifications apportées à la pile sont imprimées et un autre exemple, qui donne un résultat erroné, puisqu'une modification n'est pas imprimée. Les deux exemples ci-dessous fonctionnent correctement si incremental = false .

 # Does work
io = IOBuffer ()
stack = CrayonStack (incremental = true )
print (io, push! (stack, Crayon (foreground = :red )))
print (io, push! (stack, Crayon (foreground = :red )))
print (io, stack, " This will be red " )
print ( String ( take! (io)))

# Does not work
io = IOBuffer ()
stack = CrayonStack (incremental = true )
push! (stack, Crayon (foreground = :red )) # <- not printing the stack even though we modify it!
print (io, push! (stack, Crayon (foreground = :red )))
print (io, stack, " This will not be red " )
print ( String ( take! (io)))

La raison pour laquelle le dernier exemple n'a pas fonctionné est que la pile remarque qu'il n'y a pas de changement d'état du texte lors du deuxième appel à push! , puisque le premier plan est resté rouge. Échec de l'impression de la pile après le premier push! signifiait que l'état du terminal et l'état de la pile étaient désynchronisés.