Working With Git

Como segunda entrada de mi trabajo con Git, pongo los comando, acciones y sentencias que mejor podemos utilizar para utilizar la herramienta.

Esta es una aproximación al trabajo con Git resumida de Git Immersion. Web que os recomiendo.

1) Una vez Instalado GIT, inicializar el entorno:

 Para Identificar al usuario:
git config –global user.name “Your Name”
git config –global user.email “your_email@whatever.com”
Para definir el salto de línea:
Para Unix/Mac:
git config –global core.autocrlf input
git config –global core.safecrlf true
Para Windows:
git config –global core.autocrlf true
git config –global core.safecrlf true
Para Cambiar el editor de Texto:
git config –global core.editor vi
Si quieres revisar la configuración resultante puedes ejecutar:
git config –list
2) Subiendo el primer fichero a git
Se crea un directorio para trabajar (mkdir)
Y dentro creamos el primer fichero
Creamos nuestro repositorio con “git init” (Esto nos creará un repositorio dentro del directorio .git)
Subimos el fichero que hemos creado con:
git add nombre_fichero
git commit -m “Mi primer fichero subido”
Puedes ver que todo ha ido ok con: git status
3) Ahora si modificamos el fichero con el que estamos trabajando y hacemos git status, veremos que git ha detectado que se ha modificado el fichero de trabajo con respecto al subido al repositorio.
4) Para volver ha subir la modificación volvemos ha ejecutar:
git add nombre_fichero
Si hacemos git status, veremos que está pendiente de subir el fichero y con git commit -m “Subo fichero modificado” grabamos los cambios.
Si hacemos git reset, anulamos los cambios que vamos a realizar.
Se ha de tener presente que git trabaja por cambios en el fichero. Si hacemos un cambio en el fichero y luego git add, pero no commit, los siguientes cambios en el fichero no se subirán si no volvemos ha hacer git add.
5) Utilización de git log
git log nos deja visualizar los cambios que vamos subiendo al repositorio. Si queremos cambiar su salida, podemos hacer:
git log –pretty=oneline –max-count=2
git log –pretty=oneline –since=’5 minutes ago’
git log –pretty=oneline –until=’5 minutes ago’
git log –pretty=oneline –author=<your name>
git log –pretty=oneline –all
git log –all –pretty=format:’%h %cd %s (%an)’ –since=’7 days ago’
git log –pretty=format:’%h %ad | %s%d [%an]’ –graph –date=short
Nota: Para explotar el log de git existe la aplicación gitk
6) Definiendo Alias para los comandos
Para abreviar los comandos, como por ejemplo los de log, git nos permite definir alias:
[alias]
  co = checkout
  ci = commit
  st = status
  br = branch
  hist = log –pretty=format:’%h %ad | %s%d [%an]’ –graph –date=short
  type = cat-file -t
  dump = cat-file -p
entrando en el fichero $HOME/.gitconfig.
ahor ejecutanto git hist nos mostrará el log como nosotros queremos.
lógicamente tambien podemos definir alias a nivel de sistemas como:
alias gs=’git status ‘
alias ga=’git add ‘
alias gb=’git branch ‘
alias gc=’git commit’
alias gd=’git diff’
alias go=’git checkout ‘
alias gk=’gitk –all&’
alias gx=’gitx –all’
alias got=’git ‘
alias get=’git ‘
y ejecutar go <branch>
7) Para recuperar ficheros subidos, primero revisamos el historial con git hist (si tenemos el alias correspondiente) y nos aparece:
* f78cbd1 2015-06-11 | Subir fichero con comentario (HEAD, master) [jrv]
* 65cf24e 2015-06-11 | Entrada Nueva [jrv]
* 8536e39 2015-06-11 | Subo fichero modificado [jrv]
* 5d0f852 2015-06-11 | Primer Fichero Subido [jrv]
y para recuperar la version que queremos lo hacemos mediante:  git checkout <hash> indicada en el primer campo.
Para recuperar los archivos de un repositorio BARE: sudo git –work-tree=. –git-dir=/opt/repositorios/glpi.bit checkout -f
8) Incluyendo Tags en nuestro workflow
Podemos etiquetar una línea de desarrollo mediante: git tag v1. Con esto nos permite referencias la lista de ficheros que tenemos.
Con “git tag” podemos ver los tag que hemos ido incluyendo.
9) Como “revertir” un commit
Si haciendo un commit nos equivocamos, tenemos la opción de tirar hacia atrás el cambio mediante el comando: git revert HEAD
10) “Revertir” un Historial 
Primero marcamos la rama para volverla a encontrarla otra vez: git tab err
Segundo revisamos desde el punto que queremos restaurar: git hist
Tercero eliminamos desde el tag que queremos: git reset –hard v1
Para ver el historial completo de las versiones que contiene el repositorio, se puede revisar mediante: git hist –all
Si se quiere eliminar un tag, por ejemplo por estar equivocado, se puede realizar con: git tag -d err
11) Moviendo un fichero a un directorio.
Si queremos mover un fichero de un directorio a otro, lo debemos realizar con: git mv nombre_fichero directorio/
con ello movemos el fichero y le informamos a git de donde se encuentra. De otra manera detecta que se ha borrado.
Posteriormente a esto debemos hacer el commit.
12) El directorio .git tiene una arquitectura propia del repositorio. Para saber más sobre ella, visitar: http://gitimmersion.com/lab_22.html
13) Trabajo con Ramas
Para la creación de una rama, hacemos el siguiente comando: git checkout -b <brand_name>. Hacemos un checkout hacia una rama. Con status nos muestra que ahora trabamos en esta nueva rama.
Para añadir ficheros a la nueva rama simplemente tenemos que hacerlo con: git add y git commit. Como subiendo un fichero “normalmente” pero ahora trabajamos en esta nueva rama.
Para cambiar por las diferentes ramas, simplemente tenemos que hacer: git checkout <nombre_rama>. Con esto nos van cambiando los ficheros con los que vamos trabajando en función de la rama donde estamos.
Para Juntar dos ramas, debemos ir a la rama que queremos fusionar y posteriormente fusionarla con la inicial:
git checkout <rama_a_fusionar>
git merge <rama_con_la_que_se_fusiona>
Para resolver conflictos entre ramas se puede consultar el siguiente enlace: http://gitimmersion.com/lab_30.html
Una alternativa al merge, es el “Rebasing”. Para conocer más de sus diferencias, consultar: http://gitimmersion.com/lab_34.html
14) Trabajo con multiples repositorios 
Para clonar un repositorio, simplemente ejecutar el siguiente comando: git clone repositorio_original repositorio_clonado. Con ello nos hace una copia idéntica del repositorio.
Si se hace un git hist, se puede observar que el historial es parecido aparte de las ramas que aparecen como original/<nombre_rama>:
* be4a9fb 2015-06-11 | Anyadimos el fichero 1 en la nueva rama (HEAD, origin/master, origin/developer, origin/HEAD, master) [jrv]
* 1432a1d 2015-06-11 | Anydido Fichero 2 en nueva rama [jrv]
* 6f4dcc6 2015-06-11 | Movemos Fichero [jrv]
* f49b8f0 2015-06-11 | Revert “Fichero equivocado” [jrv]
* 59979c4 2015-06-11 | Fichero equivocado [jrv]
* 09cb03f 2015-06-11 | subimos los 2 ficheros con linea nueva [jrv]
* 350f1cc 2015-06-11 | Anyado fichero 1 (tag: v1-beta) [jrv]
* f78cbd1 2015-06-11 | Subir fichero con comentario (tag: v1) [jrv]
* 65cf24e 2015-06-11 | Entrada Nueva [jrv]
* 8536e39 2015-06-11 | Subo fichero modificado [jrv]
* 5d0f852 2015-06-11 | Primer Fichero Subido [jrv]
Para ver la información del repositorio origen, desde el clon, ejecutar: git remote show origin
Los repositorios origen, generalmente residen en otros servidores. Para centralizar todo el desarrollo.
Para trabajar con ramas remotas, podemos consultarlas mediante: git branch -a. Nos mostrará tanto las ramas locales como las remotas.
15) Si se modificar el repositorio original y se quieren descargar los cambios del directorio original, haciendo “git fetch” descargará los cambios realizados, pero para fusionarlos con el repositorio local se debe ejecutar, también: “git merge origin/master”
En el primer comando no se verán los cambios realizados en el repositorio origen, pero una vez se ha fusionado con merge, aparecerán en los ficheros modificados.
Para realizar los dos comandos como uno solo, se puede ejecutar: “git pull”. Con ello sustituye a git fetch + git merge origin/master.
16) Trabajo con Ramas locales
Con las siguientes comandos, se puede crear una rama local que apunta a una remota:
git branch –track greet origin/greet
git branch -a
git hist –max-count=2
17) Repositorio BARE
Para crear un repositorio BARE, se crea mediante: git init –bare hello.git
Básicamente la converción dice que los repositorios bare finalizan en .git.
Los repositorios BARE son repositorios expeciales con los cuales no se pueden trabajar directamente y que se utilizan básicamente para compartir/centralizar la información.
18) Trabajando con Repositorios BARE
a) Para subir los ficheros a un repositorio remoto bare:
Para añadir un repositorio remoto BARE en un repositorio como nuestro repositorio original, ejecutaríamos: git remote add shared ../hello.git
Para subir los cambios que hacemos en nuestro repostorio, en un respositorio BARE, lo ejecutaríamos con: git push shared master
b) Para bajar los datos desde un repositorio remoto bare:
Para añadir un repositorio remoto BARE en un repositorio como nuestro repositorio original, ejecutaríamos: git remote add shared ../hello.git
Añadimos la rama con la que queremos trabajar: git branch –track shared master
Bajamos los datos desde el repositorio principal: git pull shared master
c) Formas de Compartir el repositorio del servidor:
c.1) git daemon –verbose –export-all –base-path=.
Para bajarlo ahora desde el cliente, se ejecutaría: git clone git://localhost/hello.git network_hello
Si se quieren recibir ficheros se tiene que añadir –enable=receive-pack. CUIDADO porque no se tiene autenticación con este método.
c.2) git clone ssh://user@host/path/to/repo.git
Enjoy!!!

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s