Version 45
Visibility: Open to anyone
    Ver logs y commits

    Además del clásico log que obtenemos con git log existen otros formatos que nos muestran los datos de una forma más ordenada y amigable. A continuación se listan algunos de estos formatos como así también un log alternativo (donde se muestra el historial de la posición de nuestro HEAD) y algunos métodos para ver los commits directamente desde la terminal.

    Ver log
    git log
    
    Ver log en formato comprimido con SHA-1 corto
    git log --pretty=oneline --abbrev-commit
    

    Esto mismo se puede hacer usando únicamente --oneline

    Ver log por autor
    git log --author=jiveUserName
    

    Al igual que con git log, es posible pedir los datos en formato comprimido y con sha-1 corto.

    Ver log por mensaje
    git log --grep="mensajeDelCommit"
    

    Este comando nos muestra el log con aquellos commits que contengan el string pasado como parámetro.

    Ver log por archivo
    git log -- pathDelArchivo
    

    Este comando nos muestra solo el log del archivo que le pasamos como parámetro. Como se ve en la imagen, pasar el path completo o ir hasta la carpeta contenedora y pasar solo el nombre del archivo es lo mismo.

    Ver log por contenido
    git log -S "stringQueAndamosBuscando"
    

    Este comando nos va a mostrar el log de los commits donde se haya trabajado sobre el string que pasamos como parámetro con el fin de saber cuando fue creado y/o modificado. Este string puede ser, por ejemplo, una linea de código, nombre de método, etc. En la imagen se ve que en el primer commit se creó y en el segundo solo se modificó.

    Ver Reflog

    El Reflog nos muestra dónde estuvo nuestro HEAD últimamente.

    git reflog
    
    Ver commit
    git show sha1DelCommit
    

    Se puede usar tanto el SHA-1 largo como el corto.

    Staging Interactivo

    Una de las tantas herramientas que trae Git nos ofrece la oportunidad de poder commitear, cuando tenemos varios archivos modificados, solo aquellos archivos que queramos o solo ciertas partes de los mismos. Esto se convierte en una herramienta útil cuando tenemos modificados muchos archivos y los queremos commitear ordenadamente en vez de tener un único gran commit.

    Ingresar al modo interactivo (ambos comandos son equivalentes)
    git add -i
    git add --interactive
    

    Una vez que entramos al modo interactivo podemos ver cuales son los archivos que tenemos modificados y también podemos ver varias opciones en la parte inferior. Estas opciones son las que vamos a seleccionar para ejecutar la acción que queramos. Las opciones son:

    1. status: actualiza el estado de los archivos modificados. (en la imagen el primer archivo fue agregado para ser commiteado)
    2. update: sirve para seleccionar aquellos archivos que queramos agregar para ser commiteados. Una vez que elegimos la opcion update vamos a poder ingresar el número de cada archivo en update>>. (en la imagen agregamos los dos primeros archivos y después le damos a status(1) para ver el estado de los archivos)
    3. revert: sirve para quitar los archivos que hayamos agregado para commitear. (en la imagen quitamos el primer archivo, quedando solo el segundo para comittear)
    4. add untracked: sirve para agregar al commit aquellos archivos que no forman parte del repositorio de Git (que no tienen seguimiento). Estos archivos no aparecen a primera vista en el modo interactivo sino que aparecen una vez que seleccionamos la opción add untracked. (en la imagen agregamos un untracked file y después le damos a status(1) para ver el estado de los archivos)
    5. patch: sirve para agregar al commit solo ciertos cambios dentro de un mismo archivo, dejando el resto para agregar luego o no. Para hacer esto, una vez que elegimos el archivo sobre el cual trabajar, el script nos va llevando uno por uno a cada cambio que se haya hecho dentro del archivo y nos pregunta que queremos hacer con dicho cambio. Ingresando la opción ? podemos ver una breve descripción de cada una de las opciones. (en la imagen tenemos un archivo con 3 modificaciones, de las cuales solo la 3ra va a ser agregada. Luego se actualiza el estado con status(1))
    6. diff: sirve para ver qué difiere entre el archivo que modificamos y la versión original del mismo. (antes es necesario agregar el archivo con update)
    7. exit: salir del modo interactivo.
    8. help: muestra una breve descripción de cada opción.
    Stashing

    Stash es una herramienta que nos puede ser muy útil cuando usamos un único directorio para trabajar y necesitamos, a mitad de un trabajo, cambiar de branch sin perder los cambios que tenemos hechos. Para esto se ejecuta el comando git stash o git stash save, el cual guarda en una pila todos los cambios sin commitear que tenemos hasta el momento para posteriormente recuperarlos.

    Agregar un nuevo stash a la pila (ambos comandos son equivalentes)
    git stash
    git stash save
    

    En la imagen podemos ver cómo luego del git stash el archivo modificado ya no aparece cuando consultamos el estado con git status. Ahora ya podríamos cambiar de branch tranquilamente sin perder los cambios realizados.

     

    En esta pila no solo se guarda un solo stash sino que podemos guardar tantos como queramos y todos pueden ser recuperados.

    Ver los stash guardados
    git stash list
    
    Recuperar un stash
    git stash apply
    git stash apply stash@{n}
    

    Para recuperar algún stash anterior se usa el comando git stash apply stash@{n} indicando el numero del stash. Si no se especifica ninguno y solo se usa git stash apply, Git asume que queremos recuperar el último stash y actuá en consecuencia.

     

    Al igual que con staging, también es posible hacer stashing de solo aquellos cambios que queramos, agregando el operador --patch. Al hacer esto Git nos va a ir llevando uno por uno a cada cambio realizado y preguntando si queremos, o no, agregarlo al stash.

    Si quisiéramos eliminar algún stash de la pila podemos hacerlo mediante el comando git stash drop. Este comando por si solo nos eliminaría de la pila el último stash realizado, pero podemos indicar el que queramos mediante git stash drop stash@{n}. Otra variante es utilizar el comando git stash pop, el cual recupera el último stash realizado y luego lo elimina de la pila.

    Eliminar cualquier otro stash
    git stash drop stash@{n}
    

    Algo que cabe destacar es que no necesariamente debemos estar en el mismo branch donde hicimos el stash para poder recuperarlo y aplicarlo. Por ejemplo, tranquilamente podemos haber modificado algún archivo y hecho stash en develop, luego cambiar de branch a develop8 y recuperarlo ahi. En caso de no poder aplicarse dicho cambio por algún conflicto Git nos lo notifica.

    Searching

    En lo que a búsquedas se refiere, Git cuenta con herramientas que nos pueden ser muy útiles a la hora de encontrar lo que buscamos. En este caso vamos a ver algunas funcionalidades del comando grep. Básicamente lo que este comando hace es buscar el término que le indiquemos a través de todos los archivos de nuestro directorio de trabajo. A diferencia de git log --grep="mensajeDelCommit", este comando nos muestra el archivo en el cual aparece, dentro de su código fuente, nuestro término de búsqueda. Se le puede pasar, por ejemplo, el modificador -n para que nos muestre el número de la linea en la cual aparece nuestro término de búsqueda

    Búsqueda normal con numero de linea
    git grep -n términoDeBúsqueda
    

    También le podríamos pedir que en vez de mostrarnos dónde aparece nuestro término nos muestre la cantidad de veces que aparece en cada archivo. Para esto tenemos que usar el modificador --count.

    Cantidad de ocurrencias por archivo
    git grep --count términoDeBúsqueda
    

    Algo que también nos puede ser útil es buscar en qué métodos o funciones aparece nuestro término. Para esto usamos el modificador -p.

    Búsqueda por métodos
    git grep -p términoDeBúsqueda
    

    Git también nos brinda la oportunidad de buscar dentro del log de commits para, por ejemplo, saber cuando una variable fue creada y/o modificada. Para esto se usa el modificador -S, el cual le dice a Git que nos muestre solo aquellos commits donde se haya trabajado sobre esa variable.

    Búscar historial de modificaciones
    git log -S términoDeBúsqueda --oneline
    

    Otra herramienta que nos puede ser muy útil es  blame. Ésta nos va a mostrar cuándo fue la última vez que cada linea de código se modificó y por quién fue modificada.

    Ver última modificación por linea
    git blame pathAlArchivo
    

    También es posible, para no tener que revisar todo el archivo, buscar por rango. Para esto agregamos el modificador -L seguido del rango en el que queramos buscar.

    Ver última modificación (por rango)
    git blame -L num1,num2 pathAlArchivo
    

    O si no, para ser mas exactos, podemos buscar indicando el número de la linea o el texto que contiene

    Ver última modificación (por número de linea)
    git blame pathAlArchivo | grep --line-number num
    
    Ver última modificación (por contenido de la linea)
    git blame pathAlArchivo | grep textoContenidoEnLaLinea
    

     

     

    Lock / Unlock Branch using gitolite

    https://brewspace.jiveland.com/thread/301409