Una salida de gráfico git similar a una tabla agradable y limpia para conchas
con hashes habitualmente además del árbol de gráficos
o en una columna extra
Editar : ¿Quieres comenzar de inmediato sin leer las explicaciones? Use fragmentos de código de alias, script o funciones de git de la sección EDIT 5 a continuación o incluso la forma más cómoda con EDIT 6 .
Hasta ahora, en todas las respuestas a esta pregunta, ninguna mostró un resultado de aspecto de tabla limpio para los depósitos. Lo más cercano fue esta respuesta de los evangelios desde donde comencé.
El punto central de mi enfoque es contar solo los caracteres del árbol que se muestran al usuario. Luego, llénelos a una longitud personal con espacios en blanco.
Aparte de git, necesitas estas herramientas
- grep
- pegar
- printf
- sed
- seq
- tr
- baño
principalmente a bordo con cualquier distribución de Linux.
El fragmento de código es
while IFS=+ read -r graph hash time branch message;do
# count needed amount of whitespaces and create them
whitespaces=$((9-$(sed -nl1000 'l' <<< "$graph" | grep -Eo '\\\\|\||\/|\ |\*|_' | wc -l)))
whitespaces=$(seq -s' ' $whitespaces|tr -d '[:digit:]')
# show hashes besides the tree ...
#graph_all="$graph_all$graph$(printf '%7s' "$hash")$whitespaces \n"
# ... or in an own column
graph_all="$graph_all$graph$whitespaces\n"
hash_all="$hash_all$(printf '%7s' "$hash") \n"
# format all other columns
time_all="$time_all$(printf '%12s' "$time") \n"
branch_all="$branch_all$(printf '%15s' "$branch")\n"
message_all="$message_all$message\n"
done < <(git log --all --graph --decorate=short --color --pretty=format:'+%C(bold 214)%<(7,trunc)%h%C(reset)+%C(dim white)%>(12,trunc)%cr%C(reset)+%C(214)%>(15,trunc)%d%C(reset)+%C(white)%s%C(reset)' && echo);
# paste the columns together and show the tablelike output
paste -d' ' <(echo -e "$time_all") <(echo -e "$branch_all") <(echo -e "$graph_all") <(echo -e "$hash_all") <(echo -e "$message_all")
Para calcular los espacios en blanco necesarios usamos
sed -nl1000 'l' <<< "$graph"
para obtener todos los caracteres (hasta 1000 por línea) que seleccione solo los caracteres del árbol: * | / \ _ y espacios en blanco con
grep -Eo '\\\\|\||\/|\ |\*|_'
finalmente contarlos y restar el resultado de nuestro valor de longitud elegido, que es 9 en el ejemplo.
Para producir la cantidad calculada de espacios en blanco utilizamos
seq -s' ' $whitespaces
y truncar los números de posición con
tr -d '[:digit:]'
que agregarlos al final de nuestra línea gráfica. ¡Eso es!
Git tiene la buena opción de formatear la longitud de los especificadores de salida ya con la sintaxis'%><(amount_of_characters,truncate_option)' , que agrega espacios en blanco desde el lado izquierdo '>' o derecho '<' y puede truncar caracteres desde el inicio 'ltrunc', 'mtrunc' medio o final 'trunc'.
Es importante que los cmd de printf anteriores usen los mismos valores de longitud para la columna git correspondiente.
Diviértete para diseñar tu propia salida de aspecto limpio a tus necesidades.
Extra:
Para obtener el valor de longitud correcto, puede usar el siguiente fragmento
while read -r graph;do
chars=$(sed -nl1000 'l' <<< "$graph" | grep -Eo '\\\\|\||\/|\ |\*|_' | wc -l)
[[ $chars -gt ${max_chars:-0} ]] && max_chars=$chars
done < <(git log --all --graph --pretty=format:' ')
y use $ max_chars como el valor de longitud correcto arriba.
EDITAR 1 : Acabo de notar que el carácter subrayado también se usa en el árbol git y edita los fragmentos de código anteriores en consecuencia. Si faltan otros caracteres, deje un comentario.
EDIT 2 : si desea deshacerse de los corchetes alrededor de las entradas de rama y etiqueta, simplemente use "% D" en lugar de "% d" en el comando git, como en EDIT 3.
EDITAR 3 : ¿Quizás la opción de color "automático" es la que más prefiere para las entradas de rama y etiqueta?
Cambiar esta parte del comando git (color 214 )
%C(214)%>(15,trunc)%D%C(reset)
a auto
%C(auto)%>(15,trunc)%D%C(reset)
EDIT 4 : ¿O te gusta tu propia mezcla de colores para esa parte, una salida elegante con cabeza parpadeante?
Para poder diseñar primero el encabezado, los nombres de las ramas y las etiquetas, necesitamos la opción de color "automático" en nuestro comando git como en EDIT 3.
Luego podemos reemplazar los valores de color conocidos con los nuestros agregando estas 3 líneas
# branch name styling
branch=${branch//1;32m/38;5;214m}
# head styling
branch=${branch//1;36m/3;5;1;38;5;196m}
# tag styling
branch=${branch//1;33m/1;38;5;222m}
justo antes de la línea
branch_all="$branch_all$(printf '%15s' "$branch")\n"
en nuestro fragmento de código. Los valores de reemplazo producen los colores anteriores.
Por ejemplo, el valor de reemplazo para la cabeza es
3;5;1;38;5;196
donde 3; significa cursiva, 5; para parpadear y 1; 38; 5; 196 para el color. Para más información comienza aquí. Nota: Este comportamiento depende de su terminal favorito y, por lo tanto, puede no ser utilizable.
PERO puedes elegir el valor de color que prefieras.
DESCRIPCIÓN GENERAL de los valores de color git y equivalentes ANSI
Aquí encontrará una lista con la opción de color / estilo git .
Si necesita la salida en su consola para obtener colores precisos (la imagen de arriba se reduce mediante stackoverflow) puede producir la salida con
for ((i=0;i<=255;i++));do
while IFS='+' read -r tree hash;do
echo -e "$(printf '%-10s' "(bold $i)") $hash $(sed -nl500 'l' <<< "$hash"|grep -Eom 1 '[0-9;]*[0-9]m'|tr -d 'm')"
done < <(git log --all --graph --decorate=short --color --pretty=format:'+%C(bold '$i')%h%C(reset)'|head -n 1)
done
en su ruta de proyecto git que usa el primer commit de su salida de registro git.
EDITAR 5 : Como mencionó el miembro "Andras Deak", hay algunas formas de usar este código:
1) como un alias :
alias no acepta parámetros, pero una función puede , por lo tanto, solo defina en su .bashrc
function git_tably () {
unset branch_all graph_all hash_all message_all time_all max_chars
### add here the same code as under "2) as a shell-script" ###
}
y llame a la función git_tably (derivada de tablelike) directamente debajo de su ruta de proyecto git o desde donde desee con su ruta de proyecto git como primer parámetro.
2) como un script de shell :
Lo uso con la opción de pasar un directorio de proyecto git como primer parámetro o, si está vacío, tomar el directorio de trabajo como el comportamiento normal. En su totalidad tenemos
# edit your color/style preferences here or use empty values for git auto style
tag_style="1;38;5;222"
head_style="1;3;5;1;38;5;196"
branch_style="38;5;214"
# determine the max character length of your git tree
while IFS=+ read -r graph;do
chars_count=$(sed -nl1000 'l' <<< "$graph" | grep -Eo '\\\\|\||\/|\ |\*|_' | wc -l)
[[ $chars_count -gt ${max_chars:-0} ]] && max_chars=$chars_count
done < <(cd "${1:-"$PWD"}" && git log --all --graph --pretty=format:' ')
# create the columns for your prefered tablelike git graph output
while IFS=+ read -r graph hash time branch message;do
# count needed amount of whitespaces and create them
whitespaces=$(($max_chars-$(sed -nl1000 'l' <<< "$graph" | grep -Eo '\\\\|\||\/|\ |\*|_' | wc -l)))
whitespaces=$(seq -s' ' $whitespaces|tr -d '[:digit:]')
# show hashes besides the tree ...
#graph_all="$graph_all$graph$(printf '%7s' "$hash")$whitespaces \n"
# ... or in an own column
graph_all="$graph_all$graph$whitespaces\n"
hash_all="$hash_all$(printf '%7s' "$hash") \n"
# format all other columns
time_all="$time_all$(printf '%12s' "$time") \n"
branch=${branch//1;32m/${branch_style:-1;32}m}
branch=${branch//1;36m/${head_style:-1;36}m}
branch=${branch//1;33m/${tag_style:-1;33}m}
branch_all="$branch_all$(printf '%15s' "$branch")\n"
message_all="$message_all$message\n"
done < <(cd "${1:-"$PWD"}" && git log --all --graph --decorate=short --color --pretty=format:'+%C(bold 214)%<(7,trunc)%h%C(reset)+%C(dim white)%>(12,trunc)%cr%C(reset)+%C(auto)%>(15,trunc)%D%C(reset)+%C(white)%s%C(reset)' && echo);
# paste the columns together and show the tablelike output
paste -d' ' <(echo -e "$time_all") <(echo -e "$branch_all") <(echo -e "$graph_all") <(echo -e "$hash_all") <(echo -e "$message_all")
3) como un alias git :
Quizás la forma más cómoda es agregar un alias git en su .gitconfig
[color "decorate"]
HEAD = bold blink italic 196
branch = 214
tag = bold 222
[alias]
count-log = log --all --graph --pretty=format:' '
tably-log = log --all --graph --decorate=short --color --pretty=format:'+%C(bold 214)%<(7,trunc)%h%C(reset)+%C(dim white)%>(12,trunc)%cr%C(reset)+%C(auto)%>(15,trunc)%D%C(reset)+%C(white)%s%C(reset)'
tably = !bash -c '" \
while IFS=+ read -r graph;do \
chars_count=$(sed -nl1000 \"l\" <<< \"$graph\" | grep -Eo \"\\\\\\\\\\\\\\\\|\\||\\/|\\ |\\*|_\" | wc -l); \
[[ $chars_count -gt ${max_chars:-0} ]] && max_chars=$chars_count; \
done < <(git count-log && echo); \
while IFS=+ read -r graph hash time branch message;do \
chars=$(sed -nl1000 \"l\" <<< \"$graph\" | grep -Eo \"\\\\\\\\\\\\\\\\|\\||\\/|\\ |\\*|_\" | wc -l); \
whitespaces=$(($max_chars-$chars)); \
whitespaces=$(seq -s\" \" $whitespaces|tr -d \"[:digit:]\"); \
graph_all=\"$graph_all$graph$whitespaces\n\"; \
hash_all=\"$hash_all$(printf \"%7s\" \"$hash\") \n\"; \
time_all=\"$time_all$(printf \"%12s\" \"$time\") \n\"; \
branch_all=\"$branch_all$(printf \"%15s\" \"$branch\")\n\"; \
message_all=\"$message_all$message\n\"; \
done < <(git tably-log && echo); \
paste -d\" \" <(echo -e \"$time_all\") <(echo -e \"$branch_all\") <(echo -e \"$graph_all\") \
<(echo -e \"$hash_all\") <(echo -e \"$message_all\"); \
'"
Que simplemente llamar git tablybajo cualquier ruta de proyecto.
Git es tan poderoso que puede cambiar la cabeza, las etiquetas, ... directamente como se muestra arriba y tomada desde aquí .
Otra opción elegante es seleccionar los colores de árbol que más prefieras con
[log]
graphColors = bold 160, blink 231 bold 239, bold 166, bold black 214, bold green, bold 24, cyan
eso te da una apariencia loca pero siempre salidas de registro git como una tabla
Demasiado parpadeo! Solo para demostrar lo que es posible. Muy pocos colores especificados conducen a repeticiones de color.
Una referencia completa de .gitconfig está a solo un clic de distancia.
EDITAR 6 :
Debido a sus votos positivos, mejoré el fragmento. Ahora puede alimentarlo con casi cualquier comando git log y ya no tiene que adaptar el código. ¡Intentalo!
¿Cómo funciona?
- defina sus comandos de registro git en su .gitconfig como siempre
- definir un número de columna de árbol positivo (opcional), donde se muestra el gráfico git
Entonces solo llama
git tably YourLogAlias
o
git tably YourLogAlias TreeColNumber
donde TreeColNumber sobrescribe un valor siempre definido desde arriba.
Limitación
para cada especificador en su comando de registro debe usar esta sintaxis
%><(<N>[,ltrunc|mtrunc|trunc])
además del último y solo si la columna de árbol elegida no debería ser la última
(para explicaciones, consulte https://git-scm.com/docs/pretty-formats )
- Debe elegir y usar un delimitador de columna que puede causar problemas si no es único
- el nombre de su número de columna de árbol definido para un alias de registro específico debe ser
YourLogAlias-col
Ahora el fragmento mejorado para su .gitconfig
[color "decorate"]
HEAD = bold blink italic 196
branch = 214
tag = bold 222
[alias]
# delimiter used in every mylog alias as column seperator
delim = ^
# short overview about the last hashes without graph
mylog = log --all --decorate=short --color --pretty=format:'^%C(dim white)%>(12,trunc)%cr%C(reset)^%C(bold 214)%<(7,trunc)%h%C(reset)' -5
# log with hashes besides graph tree
mylog2 = log --all --graph --decorate=short --color --pretty=format:'%C(bold 214)%<(7,trunc)%h%C(reset)^%C(dim white)%>(12,trunc)%cr%C(reset)^%C(auto)%>(15,trunc)%D%C(reset)^%C(white)%<(80,trunc)%s%C(reset)'
mylog2-col= 3
# log with hashes in an own column and more time data
mylog3 = log --all --graph --decorate=short --color --pretty=format:'^%C(dim white)%>(12,trunc)%cr%C(reset)^%C(cyan)%<(10,trunc)%cs%C(reset)^%C(bold 214)%<(7,trunc)%h%C(reset)^%C(auto)%<(15,trunc)%D%C(reset)^%C(white)%s%C(reset)'
mylog3-col= 4
tably = !bash -c '" \
delim=$(git config alias.delim); \
git_log_cmd=$(git config alias.$1); \
git_tre_col=${2:-$(git config alias.$1-col)}; \
\
i=0; \
while read -d\"$delim\" -r col_info;do \
((i++)); \
col_length[$i]=$(grep -Eo \"\\([0-9]*,[lm]*trunc\\)\" <<< \"$col_info\" | grep -Eo \"[0-9]*\" | head -n 1); \
done <<< \"$(grep -Eo \"pretty=format.*\" <<< \"$git_log_cmd$delim\")\"; \
\
while IFS= read -r graph;do \
chars_count=$(sed -nl1000 \"l\" <<< \"$graph\" | grep -Eo \"\\\\\\\\\\\\\\\\|\\||\\/|\\ |\\*|_\" | wc -l); \
[[ ${chars_count:-0} -gt ${col_length[1]:-0} ]] && col_length[1]=$chars_count; \
done < <([[ -n \"$(grep -F graph <<< \"$git_log_cmd\")\" ]] && git log --all --graph --pretty=format:\" \" && echo); \
\
while IFS= read -r line;do \
j=0; \
while IFS= read -d\"$delim\" -r col_content;do \
((j++)); \
if [[ $j -eq 1 ]];then \
chars=$(sed -nl1000 \"l\" <<< \"$col_content\" | grep -Eo \"\\\\\\\\\\\\\\\\|\\||\\/|\\ |\\*|_\" | wc -l); \
whitespaces=$((${col_length[1]}-$chars)); \
whitespaces=$(seq -s\" \" $whitespaces|tr -d \"[:digit:]\"); \
col_content[1]=\"${col_content[1]}$col_content$whitespaces\n\"; \
else \
col_content[$j]=\"${col_content[$j]}$(printf \"%${col_length[$j]}s\" \"$col_content\") \n\"; \
fi; \
done <<< \"$line$delim\"; \
for ((k=$j+1;k<=$i;k++));do \
col_content[$k]=\"${col_content[$k]}$(printf \"%${col_length[$k]}s\" \"\") \n\"; \
done; \
done < <(git $1 && echo); \
\
while read col_num;do \
if [[ -z \"$cont_all\" ]];then \
cont_all=${col_content[$col_num]}; \
else \
cont_all=$(paste -d\" \" <(echo -e \"$cont_all\") <(echo -e \"${col_content[$col_num]}\")); \
fi; \
done <<< $(seq 2 1 ${git_tre_col:-1};seq 1;seq $((${git_tre_col:-1}+1)) 1 $i); \
echo -e \"$cont_all\"; \
"' "git-tably"
Resultados:
o con el nuevo TreeColNumber sobre la marcha
OTRA VEZ: diviértete para diseñar tu propia salida de aspecto limpio a tus necesidades.
