Súper cuerdas 10D – JJMiranda

Los comandos mas usados aparte de add y commit son:

Manejando Ramas/Branchs

Para llevar el HEAD (working directory) al commit, branch o tag indicado

git checkout <commit/tag/branch>

Pone el working directory exactamente en ese commit o ese tag o ese branch.

git checkout -b <local-branch> [<start-point>]

Con -b se crea la rama local <local-branch> si no existe y se toma como punto de inicio la rama <start-point> que puede ser cualquier rama en el repositorio local inclusive las que vienen del repositorio remoto como origin/master.

–track hace que esta rama local tenga por defecto la rama <r-branch> del repositorio <remote>

git checkout –track <remote>/<r-branch>

Es igual que el de arriba creandote una rama de nombre <r-branch> sin que lo tengas que especificar.

Usar git checkout -b <local-brach> es lo mismo que usar:

git branch <local-brach>

git checkout <local-brach>

Estado en master:

git checkout -m <mibranch>

Trata de hacer un three-way merge entre master y los cambios hechos en mibranch, si no se puede se puede usar «git diff» para ver los cambios, editar los conflictos manualmente en los archivos y luego marcarlos como resueltos con «git add <nombrearchivo_resuelto>»

git branch [-r | -a]

Devuelve la lista de todas las ramas

-r devuelve la lista de ramas remotas

-a devuelve todas las listas, locales y remotas.

git branch -u <production>/<master> <master>

Para setear la rama local <master> para que le haga tracking a la rama <master> de <production>. De aquí en adelante hacer git push o git pull desde <master> lo hará contra la rama <master> de <production>.

Para que esto funcione se tiene que configurar la siguiente variable global:

git config –global push.default tracking

A partir de aquí puedes hacer git push o git pull y sabrá contra qué rama y repositorio hacerlo.

Si no se configura esta variable global el git push hará un push de todas las ramas locales contra todas las ramas remotas con los mismos nombres.

Borrando una rama que ya ha sido unida a la rama master u otra y no la necesito

git branch -d <local-branch>

Para ver todos los últimos commits de todas las ramas locales disponibles

git branch -v

Para ver que ramas han sido merge con la rama donde estoy:

Git branch –merged

Para ver que ramas no han sido merge con la rama donde estoy:

Git branch –no-merged

Manejando los merges de las ramas

Estando en <master>

git merge <hotfix>

Uno la rama <hotfix> con la rama <master>

git branch -d <hotfix>

Con esto elimino la rama hotfix que ya no necesito.

Haciendo un rebase y luego un fast-forward para mantener una historia líneal del proyecto:

git checkout <new-feature>

git rebase <master>

Voy a la rama new-feature y con rebase lo que hago es poner esta rama por delante de la rama master para mantener una historia lineal del proyecto. Luego para unir lo hecho en new-feature a master hago un standard fast-forward con merge desde master:

git checkout <master>

git merge <new-feature>

git rebase <base-branch> <topic-branch>

Sin importar en que rama estoy este comando lo que hace es revisar los cambios hechos en el topic-branch y aplicarlos en el base-branch (por lo general la rama master).

Es como hacer:

git checkout <topic-branch>

git rebase <base-branch>

El ejemplo de git rebase –onto verlo y revisarlo aquí:

http://git-scm.com/book/en/v2/Git-Branching-Rebasing

git rebase -i HEAD~3

Para modificar como quiera, de manera interactiva, los tres últimos commits.

git commit –amend

Te permite modificar el último commit, mensajes y files agregados al staging entre el último commit y el git commit –amend, creando un solo snapshot en el índice.

NOTA: Nunca pero NUNCA, se debe de hacer un GIT REBASE, GIT RESET o GIT COMMIT –AMEND a commits que se han hecho PUSH a repositorios públicos/compartidos. 

Recuperando un archivo del repositorio

Si se borra un archivo del file system y queremos restaurarlo del repositorio:

rm <nombrefile.py>

Se borra el file de casualidad, para restaurarlo:

git checkout <nombrefile.py>

Restaura el archivo <nombrefile.py> del Index. Si hay una rama que se llama <nombrefile.py> hay que usar:

git checkout — <nombrefile.py>

git checkout <a1e8fb5> <hello.py>

Restaura el archivo hello.py del commit a1e8fb5 o el Tag o Branch.

Si quiero otra vez el archivo que tengo en la última versión del index, lo restauro del HEAD:

git checkout HEAD hello.py

Para jalar UN SOLO archivo del repositorio remoto en el W.D.

git fetch <remote>

git checkout FETCH_HEAD — <file>

Agregando archivos al staging y commiteando

git add .

Agrega todos los nuevos archivos que no están siendo trakeados y todos los cambios hechos al staging listos para el próximo commit.

git add -u

Solo agrega al staging los archivos trakeados y las eliminaciones, mas NO lo archivos no trakeados.

git commit -a es casi lo mismo que git add -u && git commit con la diferencia que git add -u lo hace a partir del directorio donde esta hacia abajo y git commit -a agrega TODOS los files trakeados y los comitea dejando  por fuera los archivos no trakeados (que se tendrían que agregar con git add .)

git commit -am «Mensaje del commit»

Con -a comitea todos los archivos conocidos que ya están en el index, los nuevos archivos que no han sido agregados con git add, NO son comiteados.

-m es para el mensaje asociado al commit.

Retrocediendo la historia

git revert <commit>

Genera un nuevo commit con todos los cambios necesarios al index para que el nuevo index sea igualito al <commit> indicado.

git fetch –all

git reset –hard <origin>/<master>

Jala del remoto sin tratar de hacer un merge o rebase de nada.

Luego el reset con –hard origin/master hace que todo el repositorio local sea igual al origin/master borrando todos los archivos locales y reemplazandolos por el origen.

git reset –hard HEAD~2

Retrocede el working directory al commit menos dos (pueden ser desde 1 hasta n) de donde está el HEAD actual.

Si quiero deshacer lo que tengo temporalmente modificado antes de hacer un commit.

Para un file específico:

git checkout — <nombre-del-file>

Para deshacer todos los cambios y regresar el working directory al estado final del último commit:

git checkout — . 

Manejo de TAGs

Colocar el TAG <v1.4> para indicar versiones o releases sobre el <commit>

git tag <v1.4> <commit>

Crea el tag sin anotar (liviano) llamado v1.4 sobre el commit indicado.

git tag -a <v1.4> -m ‘my version 1.4’ <commit>

Creando un tag anotado (-a) con el mensaje dado (-m)

Si no se agrega el commit final lo hace en donde se está (HEAD), de lo contrario se agrega el TAG al commit indicado.

git show v1.4

Muestra la información anotada del tag v1.4

git tag -d <TagName>

Para eliminar el TagName del repositorio local.

git push <origin> :refs/tags/<TagName>

Para eliminar el <TagName> del repositorio <origin> remoto

git push <origin> <TagName>

Para mandar el <TagName> al servidor remoto <origin> hay que hacerlo de manera explícita con el push.

git push <origin> –tags

Para enviar todos los tags que no están en el servidor remoto <origin>.

Manejando el escondite de cambios

git stash

Salva el estado dirty del working directory (los files trackeados y los cambios staged) en una pila de cambios pendientes que luego se pueden aplicar en cualquier momento.

git stash list

Lista todos los stash que se han gradado.

git stash apply

Aplica el último stash de la pila al branch en donde estamos.

git stash apply –index

Hace lo mismo que del de arriba pero respeta los files que fueron staged y los deja tal cual en el W.D.

git stash drop stash@{0}

Elimina el stash@{0} del stack de cambios pendientes.

git stash pop

Aplica los cambios en el último stash y lo elimina del stack.

git stash branch <BranchName>

Crea una rama de nombre <BranchName> con el stash último y si todo OK, lo elimina del stack de cambios pendientes.

Misceláneas útiles

Para cargar un branch local a un branch remoto:

git push <origin>  <localbranch>:<remotebranch>

Puede ser un nombre de Branch o Tag o inclusive hacer referencia al HEAD.

Para borrar una rama remota o un tag remoto usar:

git push <origin>  :<remotebranch>

Esto lo que significa para git es: Haz un push de NADA en el local a la rama remotebranch del repositorio remoto origin, por lo que la BORRA.

Remover un file del repositorio pero no el file system, en caso no haya estado inicialmente en el .gitignore (usar -f para forzar la eliminación a lo bestia)

git rm –cached mylogfile.log

Para remover un directorio:

git rm –cached -r mydirectory

git log –oneline –decorate

El log de los commits en una sola línea. El –decorate muestra todos los punteros de las ramas y tags.

Para agregar un servidor git remoto

git remote add <nombre-remoto> <usuario_git@url_completa_ej_git.magiadigital.com:nombre_repo_ej_aps_net>

Si se quiere cambiar la URL del repositorio remoto usar:

git remote set-url nombre_repo_remoto_origin git@url_remoto:usuario/nombre_repo.git

Para ver todas las variables de cofiguración incuyendo todos los remotos:

git config -l

Para cambiar una variable del repositorio local:

git config <variable.nombre> <valor>

Para cambiar la variable globalmente usar –global:

git config –global <variable.nombre> <valor>

Ejemplos de tipos de workflows que se pueden manejar con GIT:

http://git-scm.com/book/en/v2/Distributed-Git-Distributed-Workflows

Buenas Practicas

Antes de hacer un commit asegurarse que no hay espacios en blanco que estan demas en el código, usar la siguiente instrucción para revisar los espacios en blanco demas:

git diff –check

Siempre usar antes del commit

git status

Para verificar que archivos han sido modificados, cuales son nuevos y si ya están en el stage previos al commit.

Para sincronizar un repositorio forkeado de GIT

Crear el repositorio remoto upstream apuntando al repo original (esto por supuesto solo la primera vez):

git remote add upstream https://github.com/ORIGINAL_OWNER/ORIGINAL_REPOSITORY.git

Actualizar todas las ramas del repo upstream:

git fetch upstream

Ir al local master branch:

git checkout master

Merge the changes from upstream/master into your local master branch. This brings your fork’s master branch into sync with the upstream repository, without losing your local changes.

git merge upstream/master