GIT

git init
git add biografia.txt
git commit -m "version 1"

Agrega todos los archivos: git add .

Muestra todos los cambios hechos: git show

Muestra todo los cambios del archivo: git log biografia.txt

Ver el log de una manera mas clara: git log --oneline

Ver las estadisticas de los cambios: git log --stat

Para salir: SHIFT + Z, Shift Z

Muestra un log por usuario de lo que se ha hecho: git shortlog

Mostrar solo las personas que hicieron commits: git shortlog -sn

Muestra todos los commits, incluso los borrados: git shortlog -sn --all

Muestra todos los commits sin incluir los merges: git shortlog -sn --all --no-
merges

------------------------
Para asociar repositorio
git remote add origin [URL GIT]
git push origin master

git pull origin master --allow-unrelated-histories

(Permite fusionar la rama local con la remota, se hace en caso de Fatal: refusing
to merge unrelated histories)

-----------------------
SSH
Crear Llave SSH
ssh-keygen -t rsa -b 4096 -C "carolingea@live.com"

En consola Git bash para agregar la llave:

eval $(ssh-agent -s) // Verifica que esté corriendo el proceso
ssh-add ~/.ssh/id_rsa
ssh-keygen -t rsa -b 4096 -C "carolingea@live.com"
ssh-add ~/.ssh/id_rsa

BRANCHS
Muestra la historia de las ramas:
git show-branch
git show-branch --all
Borrar la rama: git brach -D experimento
Ver las ramas locales: git branch
Ver las ramas remotas: git branch -r
Ver todas las ramas: git branch -a

GITK
Muesta la historia de manera visual:
gitk

El pool request es caracteristica de GitHub

Si es un colaborator, ya no puede crear ramas, solo puede clonar el proyecto

Fork: Es de Github. Es un camino que se parte en dos. Tomar una copia del estado
actual del proyecto y lo creo como proyecto propio.

Para ver los repos del proyecto: git remote -v

-----------------------------------------
TRAER LOS CAMBIOS DEL FORK
Un Upstream es una fuente de origen. Es un apuntador al repositorio maestro.
Agregar el proyecto padre (fork) Crea otra fuente nueva
git remote add upstream https://github.com/carolingea/hyperblog.git

Se hace un pull del upstream al master

git pull upstream master
git push origin master

-----------------------------------------
GIT IGNORE
- Crear archivo .gitignore
- Para ignorar todos los archivos .jpg, colocar dentro del archivo:
*.jpg

Subir archivo: git add .gitignore

.------------------

GITHUB PAGES
https://pages.github.com/

REBASES
- Agarrar la rama entera y pegarla al master para que quede la historia
- Desde la rama Experimento, se vuelve a pegar de la rama master. Dentro de la rama
experimento le esta diciendo que pegue mi historia a la rama del master.
git rebase master
Responderá: Current branch experimento is up to date.
Volver a la master y agregar un commit adicional
Primero se le hace git rebase a la rama experimento y luego a la master
La rama maestra desaparecer de la historia
Primero se hace rebase donde hubo los cambios que se quieren modificar y luego
rebase a la rama final
No deja historia, si la rama master avanzo mucho puede generar muchos conflictos.

STASH
Cuando no quiero hacer commit, pero necesito que mis cambios queden guardados
git stash
Guarda los cambios en un lugar temporal, sin embargo vuelve al estado anterior del
cambio
WIP: work in progress

Para ver los cambios: git stash list

Aplica el stahs: git stash pop

Si se da control + Z al cambio aplicado y se guarda, no ha pasado nada (git status)

- Para colocar el stahs en una rama: git stash branch english

- Para borrar el stash: git stash drop

GIT CLEAN
Solo borra lo que puede indexar
Para limpiar de archivos no deseados: git clean --dry-run
Para ejecutar el clean: git clean -f

GIT CHERRY
Traer solo un commit y no los demas a la rama master
Debe colocarse el hash del commit: git cherry-pich 30da063
Desde rama master: Luego se hace un git push origin master
Desde master se hace: git merge, traerá un conflicto con la rama origen del merge

GIT AMEND (ENMENDAR)

Es como si se editara el commit anterior.
Se hace un commit,
Se hace un cambio y se hace git add .
Se hace: git commit --amend
Los cambios hechos se van a pegar al commit anterior. Es decir edita el commit

GIT REFLOG Y GIT RESET

Comando que nunca olvida la historia del repos. Resetea la historia.
git reflog
Copiar la cabecera de la ultima version estable, por ejemplo: HEAD@{1}
Se puede hacer un reset --soft --hard
El soft permanece el staging o lo que este pendiente de un commit (git add .) (Hace
un reset soft)
hard resetea todo.
git reset HEAD@{1}
Aun muestra en el staging el cambio de que borró el archivo.
Para un reset hard se coloca el hash: git reset --hard 2e21bd6

GIT GREP
Usar grep para buscar en los archivos y log para los commits
Para buscar la palabra color: git grep color
Para buscar color y colocar la linea donde esta: git grep -n color
Para contar el numero de veces que se usa una palabra: git grep -c color
Buscar palabras con <>: git grep -c "<p>"
Para buscar en el log la palabra cabecera: git log -S "cabecera"

ALIAS
Crea un alias de un comando llamado stats
git config --global alias.stats "shortlog -sn --all --no-merges"
Se llama asi: git stats

BLAME
Para ver cambios linea por linea.
git blame index.html
Ver la página de ayuda del comando blame: git blame --help
Ver la página de ayuda del comando log: git log --help
Para ver quien modifico de el archivo de la linea 29 a 31: git blame index.html
-L29,31
Lo mismo pero ver el numero de la línea: git blame index.html -L29,31