Git
Internos

Repo

Un git repository es una estructura de datos en disco que almacena metadatos para un conjunto de archivos y directorios.

Vive en la carpeta .git/ tu proyecto. Cada vez que ingresas datos a git, se almacenan aquí. A la inversa, .git/ contiene cada confirmación individual.

Su estructura básica es así:

.git/
    objects/
    refs/

Objetos

git es fundamentalmente un almacén de clave-valor. Cuando agrega datos a git , construye un object y usa el hash SHA-1 del contenido del object como una clave.

Por lo tanto, cualquier contenido en git puede ser buscado por su hash:

git cat-file -p 4bb6f98

Hay 4 tipos de Object :

• blob
• tree
• commit
• tag

CABEZA ref

HEAD es una ref especial. Siempre apunta al objeto actual.

Puede ver dónde está apuntando actualmente al revisar el archivo .git/HEAD .

Normalmente, HEAD apunta a otra ref :

$cat .git/HEAD
ref: refs/heads/mainline

Pero también puede apuntar directamente a un object :

$ cat .git/HEAD
4bb6f98a223abc9345a0cef9200562333

Esto es lo que se conoce como "cabeza desprendida", porque HEAD no está unida a (apuntando a) ninguna ref , sino que apunta directamente a un object .

Refs

Una ref es esencialmente un puntero. Es un nombre que apunta a un object . Por ejemplo,

"master" --> 1a410e...

Se almacenan en `.git / refs / heads / en archivos de texto plano.

$ cat .git/refs/heads/mainline
4bb6f98a223abc9345a0cef9200562333

Esto es comúnmente lo que se llaman branches . Sin embargo, notará que en git no existe tal cosa como una branch , solo una ref .

Ahora, es posible navegar git simplemente saltando alrededor de diferentes objects directamente por sus hashes. Pero esto sería terriblemente inconveniente. Una ref le da un nombre conveniente para referirse a los objects por. Es mucho más fácil pedirle a git que vaya a un lugar específico por nombre en lugar de por hash.

Cometer objeto

Una commit es probablemente el tipo de object más familiar para los usuarios de git , ya que es lo que están acostumbrados a crear con los comandos de git commit .

Sin embargo, la commit no contiene directamente ningún archivo o dato modificado. Más bien, contiene principalmente metadatos y punteros a otros objects que contienen el contenido real de la commit .

Un commit contiene algunas cosas:

• hacha de un tree
• hash de un commit padre
• Nombre del autor / correo electrónico, nombre del comitente / correo electrónico
• cometer mensaje

Puedes ver los contenidos de cualquier commit como este:

$ git cat-file commit 5bac93
tree 04d1daef...
parent b7850ef5...
author Geddy Lee <[email protected]>
commiter Neil Peart <[email protected]>

First commit!

Árbol

Una nota muy importante es que los objetos del tree almacenan CADA archivo en su proyecto, y almacena archivos enteros, no dife. Esto significa que cada commit contiene una instantánea de todo el proyecto *.

* Técnicamente, solo los archivos modificados son almacenados. Pero esto es más un detalle de implementación para la eficiencia. Desde una perspectiva de diseño, se debe considerar que un commit contiene una copia completa del proyecto .

Padre

La línea parent contiene un hash de otro objeto de commit y puede considerarse como un "puntero principal" que apunta a la "confirmación anterior". Esto forma implícitamente un gráfico de confirmaciones conocido como el gráfico de confirmación . Específicamente, es un grafo acíclico dirigido (o DAG).

Objeto de árbol

Un tree representa básicamente una carpeta en un sistema de archivos tradicional: contenedores anidados para archivos u otras carpetas.

Un tree contiene:

• 0 o más objetos blob
• 0 o más objetos de tree

Al igual que puede usar ls o dir para enumerar los contenidos de una carpeta, puede enumerar los contenidos de un objeto de tree .

$ git cat-file -p 07b1a631
100644 blob b91bba1b   .gitignore
100644 blob cc0956f1   Makefile
040000 tree 92e1ca7e   src
...

Puede buscar los archivos en una commit encontrando primero el hash del tree en la commit , y luego mirando ese tree :

$ git cat-file commit 4bb6f93a
tree 07b1a631
parent ...
author ...
commiter ... 
 
$ git cat-file -p 07b1a631
100644 blob b91bba1b   .gitignore
100644 blob cc0956f1   Makefile
040000 tree 92e1ca7e   src
...

Objeto Blob

Un blob contiene contenidos binarios arbitrarios. Comúnmente, será texto sin formato como el código fuente o un artículo de blog. Pero podría ser tan fácil como los bytes de un archivo PNG o cualquier otra cosa.

Si tienes el hash de un blob , puedes ver su contenido.

$ git cat-file -p d429810
package com.example.project

class Foo {
 ...
}
...

Por ejemplo, puede examinar un tree como se muestra arriba y luego mirar una de las blobs en él.

$ git cat-file -p 07b1a631
100644 blob b91bba1b   .gitignore
100644 blob cc0956f1   Makefile
040000 tree 92e1ca7e   src
100644 blob cae391ff   Readme.txt

$ git cat-file -p cae391ff
Welcome to my project! This is the readmefile
...

Creando nuevos compromisos

El comando git commit hace algunas cosas:

1. Cree blobs y trees para representar el directorio de su proyecto, almacenados en .git/objects
2. Crea un nuevo objeto de commit con su información de autor, mensaje de confirmación y el tree raíz del paso 1, también almacenado en .git/objects
3. Actualiza la referencia HEAD en .git/HEAD al hash de la commit recién creada

Esto da como resultado una nueva instantánea de su proyecto que se agrega a git que está conectada al estado anterior.

Moviendo HEAD

Cuando ejecuta git checkout en un commit (especificado por hash o ref) le está diciendo a git que haga que su directorio de trabajo se vea como lo hizo cuando se tomó la instantánea.

1. Actualice los archivos en el directorio de trabajo para que coincidan con el tree dentro de la commit
2. Actualice HEAD para que apunte al hash o ref especificado

Moviendo refs alrededor

Ejecutando git reset --hard mueve git reset --hard al hash / ref especificado.

Moviendo MyBranch a b8dc53 :

$ git checkout MyBranch      # moves HEAD to MyBranch
$ git reset --hard b8dc53    # makes MyBranch point to b8dc53     

Creando nuevas referencias

Al ejecutar git checkout -b <refname> se creará una nueva referencia que apunta al commit actual.

$ cat .git/head
1f324a

$ git checkout -b TestBranch

$ cat .git/refs/heads/TestBranch
1f324a