Commands Git

folder-files.txt

FOLDERS & FILES
---------------------------



-> Entrar dentro de un directorio
	cd <nameFolder>



-> Listar el contenido de un directorio
	- Listado simple
    		ls
  	- Listado con mas detalle
	  	ls -la



-> Muestra los archivos que hay en el directorio que le indiquemos
	- Listado simple
  		ls <nameFolder>
	- Listado con mas detalle
		ls -la <nameFolder>



-> Crear un directorio
	mkdir <nameFolder>
  


-> Clonar y renombrar un directorio
	cp -r <oldNameFolder> <newNameFolder>



-> Crear un archivo
	touch <nameFile>
  
  
  
-> Ver el texto de un fichero en la terminal
	cat <nameFile>

git-branch.txt

BRANCH
---------------------------



-> Crear una rama dandole un nombre y posicionarse en ella
	- En 2 pasos
		git branch <newNameBranch>
		git checkout <newNameBranch>
	- En 1 paso
		git checkout -b <newNameBranch>
    
    
    
-> Cambiar el nombre de una rama
	git branch -m <oldNameBranch> <newNameBranch>



-> Cambiar el nombre de la rama actual
	git branch -m <newNameBranch>



-> Posicionarse en una rama
	git checkout <nameBranch>



-> Eliminar una rama
	git branch -D <nameBranch>



-> Listar todas las ramas: remotas y locales.(Rama actual '*')
	git branch -a
  


-> Listar ramas locales.
	git branch
	git branch -l
  
  
  
-> Listar ramas remotas.
	git branch -r



-> Ver a que rama apunta HEAD
	ls -la
	cat HEAD

git-commits.txt

COMMITS
---------------------------



-> Añadir al staging area (zona index)
	- una carpeta 
		git add <nameFolder>
	- un archivo
		git add <nameFile>
	- varios archivos al mismo tiempo
		git add <nameFile>	
	- todo
		git add .
		git add -A



-> Crear un commit, es decir, guardar los cambios de lo que he hecho en la historia.
Cada commit GIT tiene, un identificador único para hacer referencia a este commit.
	git commit -m “<messageCommit>”



-> Ver todo el histórico de commits.
	- Una lista de los commits con toda su información completa.
		git log
	- Resumen del histórico de commits, en una sola linea.
	Con los 7 primeros números del código identificador del commit que son los que realmente necesitamos para referenciarlo.
		git log --oneline



-> Ver el grafico del historico
	git log --oneline --graph --decorate



-> Ver la información de un commit
	git show <idCommit>



-> Sobreescribir el ultimo commit
	git commit --amend
	(pulsamos botón escape)
	:wq!



-> Si ya hemos hecho el primer add y commit de un fichero, es decir GIT ya sabe de su existencia, las próximas veces podemos usar otro comando que incluye el add y el commit en un solo comando.
	git commit -am “<messageCommit>”



-> Si tienes varios archivos añadidos a la zona index y te arrepientes, porque solo quieres hacer el commit de uno en concreto, puedes seleccionar el fichero y hacer el commit con únicamente los cambios de este.
	git <nameFile>
	git commit -am “<messageCommit>”



-> Acceder a un commit de 4 maneras diferentes:
	- De forma absoluta:
	Haciendo referencia al código que lo identifica
		git show <idCommit>
	- De forma relativa:
	Haciendo referencia al nombre de la rama del ultimo commit
		git show master
	- A través de HEAD:
	Accediendo al ultimo commit que se ha realizado
		git show HEAD
	- Por posición:
		master^
		HEAD^^
		master~<number>



-> Ver los commits si tenemos que llamarlos para ir hacia atrás con ^ y ~  en lugar de por su código de identificación
	git show-branch --more=<number>



-> Ver todos los commits hacia atrás a partir de que le indiquemos
	git log <idCommit> --oneline
	git log <nameBranch>^ --oneline



-> Identificar rangos desde el commit 10 al 12
	git log master~12..master~10



-> Mostar solo los commits en los que esta implicado un fichero
	git log --oneline -- <nameFile>



-> Podemos buscar un commit según el mensaje (expresión regular que se repita)
	git log --greg=“<regularExpresion>”



-> Un merge es el resultado de fusionar 2 o mas ramas. Los commits de merge que se crean al fusionar ramas no me suelen aportar información y podemos eliminarlos con este comando
	git log --oneline --no-merges



-> Buscar los commits por fechas (yyyy-mm-dd)
	git log --since={<date>}
	git log --before={<date>}
	git log --after={<date>}



-> Eliminar un commit
	- Elimina los commits y los deja los cambios en la zona de index.
		git reset --soft <idCommit>
	- Elimina los commits y los deja los cambios en el working directory.
		git reset --mixed <idCommit>
	- Elimina los commits y los cambios
		git reset --hard <idCommit>



-> Squashing o fusión de commits.
Borrar y pasar los commits a la zona index y hacer un commit
	git reset --soft master~<numberLastCommits>
	git commit -m “<messageCommit>”



-> Revierte los cambios de un commit y crea uno nuevo
	git revert <idCommit>

git-config.txt

CONFIGURATION
---------------------------



-> Mostrar la configuracion establecida
	git config -l
	git config --list

-> Añadir o editar el nombre de usuario
	git config --global user.name <nameUser>

-> Añadir o editar el email de usuario
	git config --global user.email <emailUser>

-> Añadir o editar el editor por defecto
	git config --global core.editor <rootEditor>

-> Cambiar el nombre y el email del autor del ultimo commit
	git commit --amend --author="John Doe <john@doe.org>"

-> Cambiar el nombre y el email del autor de multiples commits
	$ git filter-branch --env-filter "
	OLD_EMAIL='<WRONG_EMAIL>'
	NEW_NAME='<CORRECT_NAME>'
	NEW_EMAIL='<CORRECT_EMAIL>'
	if ['$GIT_COMMITTER_EMAIL' = '$OLD_EMAIL']
	then
	export GIT_COMMITTER_NAME='$NEW_NAME'
	export GIT_COMMITTER_EMAIL='$NEW_EMAIL'
	fi
	if ['$GIT_AUTHOR_EMAIL' = '$OLD_EMAIL']
	then
	export GIT_AUTHOR_NAME='$NEW_NAME'
	export GIT_AUTHOR_EMAIL='$NEW_EMAIL'
	fi
	" --tag-name-filter cat -- --branches --tags
	

git-conflict.txt

CONFLICT
---------------------------



-> Si hay un conflicto entre varias lineas, abrimos los ficheros con el editor y lo editamos
	git <nameEditor> .
	


-> Ver los cambios que se han hecho en el código (- es lo que se ha borrado y + es lo que se ha añadido)
	git diff



-> Comparar los cambios que se han hecho en el código de cada commit
	git diff <idCommit1> <idCommit2>



-> Programa para depurar conflictos
	http://sourcegear.com/diffmerge/



-> Marcar que el conflicto esta resuelto
  1. Añadir todo a la zona index
	  git add .
  2. Ver el estado de los archivos (modificados/eliminados/añadidos)
	  git status
  3. Hacer un commit de los cambios
	  git commit -m “<messageCommit>”

git-gitignore.txt

GITIGNORE
---------------------------



-> Aquí podemos encontrar ejemplos de gitignore
https://github.com/github/gitignore/



-> Generador
https://www.gitignore.io/



-> Crear un archivo .gitignore y añadir aquellos archivos que queremos que git ignore.
Es una buena practica añadir al .gitignore el fichero .DS_Store que MAC tiene por defecto, puede que dependiendo de la version instalada de GIT lo ignore, pero es mejor hacerlo y asegurarse por si tenemos instalada otra version de GIT en otro ordenador.
	# -> Escribir comentarios
	! -> Negar un patron
	foo/ -> Ignorar un directorio completo
	*html -> Ignorar los archivos .html
	*!foo.html -> Ignora todo lo que no sea .html
	/*.js -> todo partir de un directorio que acabe en .js
	js -> ignora todos los archivos que hay dentro del directorio js
	



-> Lista los archivos en el gitignore
git ls-files --other --ignored --exclude-standard



-> Forzar detecion del archivo '.gitignore'
Puede que la version de GIT no detecte directamente el fichero .gitignore como un fichero y habrá que forzar el commit.
	git add -f .gitignore

git-merge.txt

MERGE
---------------------------



-> Fusionar ramas
	- Me posiciono en la rama a la que le quiero fusionar otra rama (develop)
		git checkout <nameBranch>
	- Escojo la rama que quiero fusionar con la que estoy posicionada y la fusiono (feature)
		git merge <nameBranch>
    
    
    
-> Continuar con la fusion de ramas
	git merge --continue



-> Cancelar fusion de ramas
	git merge --abort

git-rebase.txt

REBASE
---------------------------



-> Actualizar mi rama (feature) para que salga del ultimo commit (develop)
	git rebase <nameBranch>



-> Continuar con la actualización
	git rebase --continue



-> Cancelar la actualización
	git rebase --abort

git-repositories.txt

REMOTE REPOSITORIES
---------------------------



-> Clonar un proyecto de GITHUB a mi repositorio local.
	git clone <url>



-> Añadir el repositorio remoto dentro de mi repositorio local. El nombre o alias por defecto de un repositorio remoto es origin.
	git remote add origin <url>



-> Renombrar repositorio remoto. Por defecto el repositorio local lo llama 'origin'
	git remote rename <oldNameRemoto> <newNameRemoto>



-> Listar los repositorios remotos que tengo añadidos en mi repositorio local
  - Listado simple
	  git remote
  - Listado con la URL asociada a cada repositorio remoto.
	  git remote -v



-> Subir al repositorio remoto una rama del repositorio local
	  git push <nameRepoRemote> <nameBranchRepoLocal>
	- Forzarlo
		git push -f <nameRepoRemote> <nameBranchRepoLocal>



-> Borrar una rama (ramas/ramaFuncionalidad1) del repositorio remoto (github)
	git push github :ramas/ramaFuncionalidad1



-> Fusión y sincronización de cambios. Se trae lo del remoto y lo fusiona con el local (pull request)
	- En 2 pasos:
	Si tuviéramos varias ramas seria mejor poder elegir con cual fusionarlos.
		1. Bajar los cambios remotos.
			git fetch <nameRepoRemote>
		2. Crear una rama en local y posicionarme en ella.
			git checkout <nameBranch1>
		3. Fusionarla con la que me he bajado del remoto.
			git merge origin/<nameBranch2>
	
	- En 1 paso: Si solo tengo una rama se bajan los cambios y se fusiona con ella.
		1. En un solo comando: fetch + merge
			git pull <nameRepoRemote> <nameBranch>
		2. Compruebo cuantas ramas tengo
			git branch
		3. Me trae la rama a local
			git fetch <nameRepoRemote> <nameBranch>
		4. Muestra todas las ramas que tengo en local
			git branch -a
		5. Fusiona la rama
			git merge <nameRepoRemote/nameBranch> 



-> Dar de alta un repositorio remoto en un repositorio local
	git remote add <nameRepoRemote> <urlRemote>



-> Traer la información del repositorio remoto a mi local
	git fetch <nameRepoRemote>



-> Traer la una rama del repositorio remoto a mi local
	git fetch <nameBranchRepoRemote> <nameRepoRemote>/<nameBranchRepoLocal>



-> Crear una rama en el repositorio local con la información de una rama en un repositorio remoto.
	1. Trae la info del remoto
		git fetch <nameRepoRemote>
	2. Crea una rama, me posiciona en ella y le da un nombre.
	Indicando que esta rama tendrá la información de la rama remota que hay en el repositorio remoto.
		git checkout --track -b <newNameBranchRepoLocal> <nameRepoRemote>/<nameBranchRepoRemote>



-> Clonar una rama del remoto al local
	- En 2 pasos:
		1. Crea la rama y clona la rama.
			git branch <nameBranchRepoLocal> <nameRepoRemote>/<nameBranchRepoRemote>
		2. Nos posicionaros en ella
			git checkout <nameBranchRepoLocal>
	- En 1 paso:
		1. Crea la rama, clonar la rama y posicionarnos en ella.
			git checkout -b <nameBranchRepoLocal> <nameRepoRemote>/<nameBranchRepoRemote>

git-stash.txt

STASH
---------------------------



-> Ver todas las opciones de comandos que se pueden hacer en el stash
	git stash -h



-> Pasar todo lo que hay en la zona index a la zona stash.
Esto de forma automática guarda esos cambios en un commit con el mensaje del ultimo commit en el que estaba trabajando. Al guardarlo en la zona de stash el código correspondiente que había hecho ya no estará fisicamente en el archivo y se guardará de forma temporal en el stash.
	git stash



-> Listar todos los commits que hay en la zona de stash
	git stash list



-> Recuperar lo que hay en el stash
	- Recuperar el ultimo commit de la zona stash y lo pasa al working
		git stash pop
	- Recuperar un commit en concreto sin borrarlo del stash
		git stash apply stash@{<number>}



-> Borra un commit concreto de la zona de stash
	git stash drop <idCommit>



-> Borrar todos los commits del stash
	git stash clear

git-tag.txt

TAG
---------------------------



-> Listar todos los tags
	git tag l-
	
	
	
-> Crear un tag (marca, etiqueta o puntero que apunta siempre a un commit)
	git tag -a <nameTag> -m <messageTag>



-> Renombrar un tag y subirlo al repositorio remoto
	git tag <newName> <oldName>
	git tag -d <oldName>
	git push origin :refs/tags/<oldName>
	git push --tags
	
	
	
-> Actualizar los tag del repositorio remoto
	git pull --prune --tags

git.txt

GIT
---------------------------



-> Ver el estado de los archivos de un directorio git. Si no han sido añadidos a la zona index, este no conoce de su existencia (archivos: untraked o traked)
	git status



-> Abrir un proyecto o archivo con un editor (arrastrar el archivo a la terminal para pegar la ruta en la que esta)
	- sublime text
		subl <nameFolder>
	- atom
		atom <nameFile>



-> Borra el archivo y lo añade al staging area
	git rm <nameFile>



-> Retira el archivo del control de versiones sin eliminarlo
	git rm --cached <nameFile>



-> Renombrar y detectar que se ha renombrado el fichero
	git mv <oldNameFile> <newNameFile>



-> Eliminar los cambios no guardados de un archivo o varios
	- Todo
		git checkout -- .
	- Un fichero concreto
		git checkout <idCommit> <nameFile>
	- Varios ficheros
		git checkout -- <nameFile> <nameFile>



-> Si ya he añadido el archivo con un add a la zona de index, todavía no quería hacer un commit y lo quiero sacar de la zona de index.
	- Sacar un fichero de la zona index.
		git reset <nameFile>
	- Si no he lanzado un commit todavía, y por lo tanto no se ha creado el puntero HEAD
		git rm --cached <nameFile>
	- Si ya he lanzado mi primer commit, ya que el puntero HEAD solo se crea una vez lanzado el primer commit y se va desplazando entre los commits apuntado siempre al ultimo que se ha creado.
		git reset HEAD <nameFile>

github-issue-pr.txt

GITHUB
ISSUE | PULL REQUEST
---------------------------

-> Transformar un Issue de GitHub a un Pull Request
https://jtway.co/convert-github-issue-to-pull-request-c624834835d8
https://hub.github.com/
	- Instalar el hub con Homebrew (macOS, Linux)
		brew install hub
	- Cuando uses el siguiente commando te pedira hacer login. Como contraseña deberías usar un token en su lugar.
		https://github.com/settings/tokens
	- Convertir el issue a pull request
		hub pull-request -i <numberIssue>