Git
Internes

Repo

Un git repository est une structure de données sur disque qui stocke les métadonnées pour un ensemble de fichiers et de répertoires.

Il réside dans le dossier .git/ votre projet. Chaque fois que vous validez des données sur git, elles sont stockées ici. Inversement, .git/ contient chaque commit unique.

Sa structure de base est la suivante:

.git/
    objects/
    refs/

Objets

git est fondamentalement un magasin clé-valeur. Lorsque vous ajoutez des données à git , il crée un object et utilise le hachage SHA-1 du contenu de l' object comme clé.

Par conséquent, tout contenu de git peut être recherché par son hash:

git cat-file -p 4bb6f98

Il existe 4 types d' Object :

• blob
• tree
• commit
• tag

HEAD ref

HEAD est une ref spéciale Il pointe toujours vers l'objet en cours.

Vous pouvez voir où il pointe actuellement en vérifiant le fichier .git/HEAD .

HEAD désigne normalement une autre ref :

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

Mais il peut aussi pointer directement vers un object :

$ cat .git/HEAD
4bb6f98a223abc9345a0cef9200562333

C'est ce qu'on appelle une « tête détachée » - parce HEAD est pas attaché à (montrant) tout ref , mais désigne plutôt directement à un object .

Refs

Un ref est essentiellement un pointeur. C'est un nom qui pointe vers un object . Par exemple,

"master" --> 1a410e...

Ils sont stockés dans `.git / refs / heads / dans les fichiers texte.

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

C'est communément ce qu'on appelle les branches . Cependant, vous remarquerez qu’en git il n’existe pas de branch - seulement une ref .

Maintenant, il est possible de naviguer dans git simplement en sautant sur différents objects directement par leurs hashes. Mais cela serait terriblement gênant. Un ref vous donne un nom pratique pour faire référence aux objects par. Il est beaucoup plus facile de demander à git d’aller à un endroit précis par son nom plutôt que par hash.

Objet de validation

Un commit est probablement le type d' object plus familier pour les utilisateurs git , car c'est ce qu'ils sont habitués à créer avec les commandes git commit .

Cependant, la commit ne contient pas directement de fichiers ou de données modifiés. Au contraire, il contient principalement des métadonnées et des pointeurs vers d'autres objects qui contiennent le contenu réel du commit .

Un commit contient quelques choses:

• hachage d'un tree
• hash d'un parent commit
• nom de l'auteur / email, nom du commiter / email
• commettre un message

Vous pouvez voir le contenu de tout commit comme ceci:

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

First commit!

Arbre

Une note très importante est que l’ tree objets stocke TOUS les fichiers dans votre projet et stocke des fichiers entiers non diffs. Cela signifie que chaque commit contient un instantané du projet entier *.

* Techniquement, seuls les fichiers modifiés sont stockés. Mais c'est plus un détail d'implémentation pour l'efficacité. Du point de vue de la conception, un commit doit être considéré comme contenant une copie complète du projet .

Parent

La ligne parent contient un hachage d'un autre objet commit et peut être considérée comme un "pointeur parent" qui pointe vers le "commit précédent". Cela forme implicitement un graphe de commits appelé graphe de validation . Plus précisément, il s'agit d'un graphe acyclique dirigé (ou DAG).

Objet d'arbre

Un tree représente essentiellement un dossier dans un système de fichiers traditionnel: des conteneurs imbriqués pour des fichiers ou d'autres dossiers.

Un tree contient:

• 0 ou plusieurs objets blob
• 0 ou plusieurs objets d' tree

Tout comme vous pouvez utiliser ls ou dir pour répertorier le contenu d'un dossier, vous pouvez répertorier le contenu d'un objet d' tree .

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

Vous pouvez rechercher les fichiers dans une commit en trouvant d'abord le hachage de l' tree dans la commit , puis en regardant cette 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
...

Objet blob

Un blob contient un contenu de fichier binaire arbitraire. Généralement, il s'agira d'un texte brut tel qu'un code source ou un article de blog. Mais il pourrait tout aussi bien s'agir des octets d'un fichier PNG ou de toute autre chose.

Si vous avez le hash d'un blob , vous pouvez regarder son contenu.

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

class Foo {
 ...
}
...

Par exemple, vous pouvez parcourir un tree comme ci-dessus, puis regarder l'un des blobs qu'il blobs .

$ 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
...

Créer de nouveaux commits

La commande de git commit fait quelques choses:

1. Créez des blobs et des trees pour représenter votre répertoire de projet - stockés dans des .git/objects
2. Crée un nouvel objet de commit avec les informations de votre auteur, le message de validation et l' tree racine de l'étape 1 - également stocké dans les .git/objects
3. .git/HEAD à jour la référence HEAD dans .git/HEAD au hachage du commit nouvellement créé

Cela se traduit par un nouvel instantané de votre projet ajouté à git qui est connecté à l'état précédent.

Déplacement de la tête

Lorsque vous exécutez git checkout sur un commit (spécifié par hash ou ref), vous git à git que votre répertoire de travail doit ressembler à ce qu'il a fait lors de la prise de l'instantané.

1. Mettre à jour les fichiers du répertoire de travail pour qu'ils correspondent à l' tree la commit
2. Mettre à jour HEAD pour pointer sur le hachage ou la référence spécifié

Déplacement des références

git reset --hard déplace la référence au hachage / ref spécifié.

Déplacement de MyBranch vers b8dc53 :

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

Créer de nouvelles références

git checkout -b <refname> va créer une nouvelle ref qui pointe sur le commit .

$ cat .git/head
1f324a

$ git checkout -b TestBranch

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