Crayons.jl

Otro código fuente

v4.1.1

Descargar

Cuerdas coloreadas y estilizadas para terminales.

Crayons es un paquete que simplifica la escritura de cadenas en diferentes colores y estilos en terminales. Soporta los 16 colores del sistema, tanto las extensiones de 256 colores como las de 24 bits de color verdadero, y los diferentes estilos de texto disponibles para los terminales. El paquete está diseñado para funcionar bien, no tener dependencias y cargarse rápidamente (aproximadamente 10 ms de tiempo de carga después de la precompilación).

Instalación

 import Pkg; Pkg . add ( " Crayons " )

Uso

Crear `Crayon`

Un Crayon se crea con el constructor de solo palabra clave:

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

El argumento foreground y background puede ser de tres tipos:

Un Symbol que representa un color. Los colores disponibles son black , red , green , yellow , blue , magenta , cyan , light_gray , default , dark_gray , light_red , light_green , light_yellow , light_blue , light_magenta , light_cyan y white . Para ver los colores en acción, prueba Crayons.test_system_colors() . Estos colores son compatibles con casi todos los terminales.
Un Integer entre 0 y 255. Esto utilizará los códigos de escape ANSI de 256 colores. Para ver qué número corresponde a qué color y si tu terminal admite 256 colores, utiliza Crayons.test_256_colors(codes=true) .
Una Tuple de tres Integer , todos entre 0 y 255. Esto se interpretará como un color (r, g, b) de 24 bits. Para probar la compatibilidad de sus terminales con colores de 24 bits, utilice Crayons.test_24bit_colors(codes=false) . El soporte para esto es actualmente bastante limitado pero se está mejorando en terminales continuamente, ver aquí.
Un UInt32 que representa un color dado en formato hexadecimal. Se convertirá al formato RGB correspondiente.

Los otros argumentos de palabras clave son todos de tipo Bool y determinan si el estilo correspondiente debe habilitarse o deshabilitarse explícitamente:

reset : restablecer todos los estilos y colores a los valores predeterminados
bold : texto en negrita, también ilumina los colores en algunos terminales
faint : texto tenue, no ampliamente compatible
italics : texto en cursiva, no ampliamente admitido
underline – texto subrayado
blink - texto parpadeante
negative : intercambia el primer plano y el fondo
conceal : oculta el texto, no es ampliamente compatible
strikethrough : línea horizontal que pasa por el centro del texto, no ampliamente respaldada.

Para ver texto con los diferentes estilos activos, use Crayons.test_styles()

Al no usar nothing para ninguno de los argumentos de palabras clave, ese color o estilo está inactivo y, por lo tanto, no está habilitado ni deshabilitado activamente.

Para mayor comodidad, Crayon para la versión de primer plano/fondo de los 16 colores del sistema, así como los diferentes estilos, están prefabricados y se pueden encontrar en el módulo Crayons.Box . Tienen el nombre <COLOR_NAME>_<BG/FG> para los colores de primer plano/fondo y <STYLE> para los diferentes estilos (tenga en cuenta las mayúsculas). Llamar using el módulo Crayons.Box traerá todo esto al alcance global.

Macros de cadena

Crayon también se pueden crear de forma más concisa utilizando el crayon macro de cadena. Estos están escritos usando crayon"[[fg:]<col>] [bg:<col>] ([[!]<style>] ...)" donde:

El texto dentro de un corchete es opcional.
<col> es un color dado como un número hexadecimal, (r,g,b) tupla (sin espacios), un número del 0 al 255 o uno de los 16 colores nombrados.
<style> es uno de los estilos.
! significa que el estilo está explícitamente deshabilitado.
(<style> ...) significa un número repetido de estilos, separados por espacios.

A continuación se muestran algunos ejemplos del uso de macros de cadena y el constructor equivalente.

 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)

Usando los `Crayon`

El proceso de imprimir texto coloreado y con estilo usando Crayons es simple. Al imprimir un Crayon en el terminal, se envían las secuencias de códigos correctas al terminal de modo que el texto impreso posterior adopte el color y el estilo del Crayon impreso. Por ejemplo, intente ejecutar el siguiente código en 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 " )

También es posible utilizar la sobrecarga de llamadas en Crayon creados. El Crayon se puede llamar con cuerdas y otros Crayon y los colores y estilos se anidarán correctamente. También se imprimirán las secuencias finales correctas para que los colores y estilos se deshabiliten fuera del alcance de la llamada. Esta funcionalidad quizás se muestra más claramente con algunos ejemplos:

 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 " )
     )

Nota: Para que se impriman las secuencias de colores, Julia REPL debe tener los colores activados, ya sea cuando Julia detecta automáticamente el soporte del terminal o iniciando Julia con el argumento --color=yes . Alternativamente, si existe la variable de entorno FORCE_COLOR , o se ha habilitado Crayons.force_color(::Bool) , las secuencias de colores se imprimen sin importar qué. Además, dado que relativamente pocos terminales admiten colores completos de 24 bits, es posible activar el modo de 256 colores que convierte el crayón de 24 bits en un crayón de 256 colores cuando se imprime. Esto se hace definiendo el entorno variable FORCE_256_COLORS o llamando a Crayons.force_256_colors(::Bool) . Además, algunos sistemas tienen problemas incluso con 256 colores, es posible convertir a uno de los 16 colores del sistema definiendo la variable FORCE_SYSTEM_COLORS o llamando a Crayons.force_system_colors(::Bool) . Tenga en cuenta que 16 colores (8 + 8 versiones claras) es un espacio de color bastante pequeño, por lo que es poco probable que la conversión sea muy buena.

Fusionando `Crayon`

Se pueden fusionar dos o más Crayon lo que da como resultado un nuevo Crayon con todas las propiedades de los fusionados. Esto se hace con la función merge(crayons::Crayon...) o multiplicando Crayon s usando * . Si dos Crayon especifican la misma propiedad, entonces se utiliza la propiedad del último Crayon en la lista de argumentos:

 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! "
     ))

Varios

La función inv en un Crayon devuelve un Crayon que deshace lo que hace el Crayon en el argumento de inv . Como ejemplo, inv(Crayon(bold = true)) devuelve un Crayon que desactiva la negrita.

Anidamiento avanzado de colores y estilos.

Si desea anidar colores y estilos mediante llamadas a funciones, existe el tipo CrayonStack . ¡Simplemente push! Crayon en la pila, imprima texto en la pila y luego pop! los Crayons apagados. La pila realizará un seguimiento de qué Crayon está activo actualmente. Se utiliza como 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 " )

También se puede crear un CrayonStack en modo incremental llamando CrayonStack(incremental = true) . En ese caso, CrayonStack solo imprimirá los cambios necesarios para pasar del estado de texto anterior al nuevo estado, lo que resulta en que se impriman menos códigos de color. Sin embargo, tenga en cuenta que esto significa que CrayonStack debe imprimirse en el búfer de salida para todos los cambios que se le realicen (es decir, cuando se utilizan push! y pop! ). El siguiente ejemplo muestra un ejemplo práctico en el que se imprimen todos los cambios en la pila y otro ejemplo que da un resultado incorrecto, ya que un cambio no se imprime. Los dos ejemplos siguientes funcionan correctamente 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 razón por la que el último ejemplo no funcionó es porque la pila nota que no hay ningún cambio en el estado del texto en la segunda llamada para push! , ya que el primer plano se mantuvo en rojo. ¡No se pudo imprimir la pila después del primer push! significó que el estado del terminal y el estado de la pila no estaban sincronizados.