admin_j0bot/bions-rust
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

🦀 bions-rust vague 1 : 6 briques build-your-own-x — on ne les rebuild plus jamais

Browse Source 
Principe RS-7 : « dès qu'on build un truc, plus personne n'a à le rebuild —
la seule chose à faire est l'optimisation. » (nexus/RepoVerse)
- bion-vc      : horloges vectorielles + MvReg fork-visible (LA spec
                 xion-relativiste-v0 enfin codée — CRDT testé par permutations)
- bion-triplet : l'Adressage Génératif (gen_hash BLAKE3, coords, résidu ;
                 résidu vide quand déjà-su ; align décidable au bit)
- bion-tsoinlog: journal append-only rejouable (CRC32 maison, crash-recovery)
- bion-kv      : magasin clé-valeur bitcask (compaction atomique, tombstones)
- bion-regex   : moteur Thompson NFA linéaire (jamais exponentiel — Russ Cox)
- bion-git     : mini-git content-addressed (SHA-1 maison + vecteurs officiels,
                 branches divergentes = le fork visible)
129 tests verts, clippy 0 warning, doc française = chaque bion est un cours.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
cloudion-labo
2026-08-16 01:07:31 +00:00
commit 2556698dd3
27 changed files with 6518 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

986
bion-git/src/lib.rs Normal file
View File

@@ -0,0 +1,986 @@
//! # bion-git — un mini-git from scratch, le bion du principe « fork = liberté »
//!
//! Ce bion réimplémente **le noyau conceptuel de git** depuis les principes
//! (esprit *build-your-own-x*), en std-only : un magasin d'objets
//! **content-addressed** (blob / tree / commit), des commits chaînés qui
//! forment un graphe, et des branches qui ne sont que des noms posés sur
//! des commits.
//!
//! ## Le cours en trois minutes
//!
//! Git n'est pas un « gestionnaire de versions » : c'est un **graphe de
//! contenus immuables**. Trois types d'objets suffisent :
//!
//! - **blob** — le contenu brut d'un fichier, rien d'autre (pas de nom !) ;
//! - **tree** — un répertoire : une liste triée d'entrées `(mode, nom, id)`
//! qui pointent vers des blobs ou d'autres trees ;
//! - **commit** — un instantané : un tree racine, zéro ou plusieurs parents,
//! un auteur, un message.
//!
//! Chaque objet est nommé par le **SHA-1 de son contenu** (préfixé d'un
//! en-tête `"{type} {taille}\0"`). Conséquences magiques :
//!
//! - deux contenus identiques n'existent **qu'une fois** (déduplication) ;
//! - un objet ne peut pas être modifié sans changer de nom (immuabilité) ;
//! - un commit scelle *transitivement* toute son histoire : son id dépend
//! de son tree ET de ses parents, donc de tout le passé (chaîne de Merkle,
//! la même idée que les blockchains — git l'a fait en 2005) ;
//! - **forker est gratuit** : une branche n'est qu'un fichier de 41 octets
//! contenant un id. Deux branches divergentes partagent tout leur passé
//! commun sans copier un seul octet.
//!
//! Dans le vocabulaire du xerboxion : une branche est un **chemin** dans
//! l'espace des états, un fork une **bifurcation visible** — le principe
//! gelé par RS-7 (« divergence = branche, jamais d'écrasement silencieux »),
//! ici incarné par la structure de données elle-même. C'est le socle
//! conceptuel du nexus/RepoVerse : contribution = repo, reprise = fork.
//!
//! ## Écarts assumés avec le vrai git (documentés, pédagogiques)
//!
//! - **Pas de zlib** : les objets sont stockés *non compressés* dans
//! `.bgit/objects/ab/cdef…`. Le vrai git compresse chaque objet (deflate)
//! avant écriture — mais le hash porte sur le contenu *décompressé*, donc
//! nos identifiants de **blobs et trees sont exactement ceux de git**
//! (`git hash-object` donne les mêmes ids, vérifié dans les tests).
//! - **Commits** : même structure textuelle que git (`tree`/`parent`/
//! `author`/`committer` puis message), mais l'auteur est une chaîne libre
//! et le fuseau est figé à `+0000` — les ids de commits ne coïncident
//! donc avec git que si on reproduit son format d'auteur exact.
//! - **Pas d'index (staging), pas de packfiles, pas de merge automatique** :
//! [`Repo::write_tree`] photographie un répertoire directement, et le
//! graphe accepte plusieurs parents (le merge est *représentable*, sa
//! résolution est le travail d'un autre bion — voir `bion-vc` pour la
//! sémantique causale du fork visible).
//! - **Modes** : seuls `100644` (fichier) et `40000` (répertoire) sont
//! produits ; ni exécutables, ni symlinks.
//!
//! ## Exemple complet
//!
//! ```
//! use bion_git::{Repo, Kind};
//!
//! let dir = std::env::temp_dir().join(format!("bgit-doc-{}", std::process::id()));
//! std::fs::create_dir_all(dir.join("src")).unwrap();
//! std::fs::write(dir.join("src/main.rs"), "fn main() {}\n").unwrap();
//!
//! let repo = Repo::init(&dir).unwrap();
//!
//! // Photographier le répertoire → un tree content-addressed.
//! let tree = repo.write_tree(&dir).unwrap();
//! let c1 = repo.commit(tree, &[], "premier instant", "rs-1").unwrap();
//! repo.branch("main", c1).unwrap();
//!
//! // Le fork visible : une deuxième branche sur le même commit.
//! repo.branch("fork", c1).unwrap();
//!
//! // Rematérialiser l'instantané ailleurs.
//! let dest = dir.join("restauré");
//! repo.checkout_tree(&tree, &dest).unwrap();
//! assert_eq!(std::fs::read_to_string(dest.join("src/main.rs")).unwrap(), "fn main() {}\n");
//! # std::fs::remove_dir_all(&dir).unwrap();
//! ```
pub mod sha1;
use std::fmt;
use std::fs;
use std::io;
use std::path::{Path, PathBuf};
use std::str::FromStr;
use std::time::{SystemTime, UNIX_EPOCH};
/// Identifiant d'objet : le SHA-1 (20 octets) du contenu préfixé de son
/// en-tête. S'affiche en 40 caractères hexadécimaux, comme git.
///
/// C'est un *nom absolu* : le même contenu a le même [`Id`] dans tous les
/// dépôts de l'univers — c'est ce qui rend la réplication triviale
/// (pull/apply : on ne transfère que les ids manquants).
#[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct Id(pub [u8; 20]);
impl Id {
/// Reconstruit un [`Id`] depuis ses 40 caractères hexadécimaux.
///
/// Erreur (`InvalidInput`) si la longueur ou un caractère est invalide.
pub fn from_hex(s: &str) -> io::Result<Id> {
let s = s.trim();
if s.len() != 40 {
return Err(bad_input(format!("id : 40 hex attendus, reçu {}", s.len())));
}
let mut out = [0u8; 20];
for (i, byte) in out.iter_mut().enumerate() {
let hi = hex_val(s.as_bytes()[2 * i])?;
let lo = hex_val(s.as_bytes()[2 * i + 1])?;
*byte = (hi << 4) | lo;
}
Ok(Id(out))
}
/// Les 40 caractères hexadécimaux de l'identifiant.
pub fn to_hex(&self) -> String {
sha1::to_hex(&self.0)
}
}
impl fmt::Display for Id {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&self.to_hex())
}
}
impl fmt::Debug for Id {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "Id({})", self.to_hex())
}
}
impl FromStr for Id {
type Err = io::Error;
fn from_str(s: &str) -> io::Result<Id> {
Id::from_hex(s)
}
}
fn hex_val(c: u8) -> io::Result<u8> {
match c {
b'0'..=b'9' => Ok(c - b'0'),
b'a'..=b'f' => Ok(c - b'a' + 10),
b'A'..=b'F' => Ok(c - b'A' + 10),
_ => Err(bad_input(format!(
"caractère hex invalide : {:?}",
c as char
))),
}
}
fn bad_input(msg: String) -> io::Error {
io::Error::new(io::ErrorKind::InvalidInput, msg)
}
fn bad_data(msg: String) -> io::Error {
io::Error::new(io::ErrorKind::InvalidData, msg)
}
/// Les trois natures d'objet du magasin — les mêmes que git.
#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
pub enum Kind {
/// Contenu brut d'un fichier (sans nom : le nom vit dans le tree parent).
Blob,
/// Un répertoire : liste triée d'entrées `(mode, nom, id)`.
Tree,
/// Un instantané daté et signé d'un tree, chaîné à ses parents.
Commit,
}
impl Kind {
/// Le mot-clé exact utilisé dans l'en-tête d'objet (compatible git).
pub fn as_str(&self) -> &'static str {
match self {
Kind::Blob => "blob",
Kind::Tree => "tree",
Kind::Commit => "commit",
}
}
fn from_bytes(b: &[u8]) -> io::Result<Kind> {
match b {
b"blob" => Ok(Kind::Blob),
b"tree" => Ok(Kind::Tree),
b"commit" => Ok(Kind::Commit),
_ => Err(bad_data(format!(
"type d'objet inconnu : {:?}",
String::from_utf8_lossy(b)
))),
}
}
}
/// Une entrée de tree : `(mode, nom, id)` — un fichier ou un sous-répertoire.
#[derive(Clone, PartialEq, Eq, Debug)]
pub struct TreeEntry {
/// Mode façon git : `"100644"` pour un fichier, `"40000"` pour un tree.
pub mode: String,
/// Nom *local* (sans `/`) — le chemin complet émerge de la récursion.
pub name: String,
/// L'objet pointé (blob ou tree).
pub id: Id,
}
/// Un commit relu depuis le magasin — l'instantané et sa place dans le graphe.
#[derive(Clone, PartialEq, Eq, Debug)]
pub struct Commit {
/// L'identifiant du commit lui-même.
pub id: Id,
/// Le tree racine : l'état complet du monde à cet instant.
pub tree: Id,
/// Zéro parent = racine ; un = pas ordinaire ; deux ou plus = merge.
pub parents: Vec<Id>,
/// Auteur, chaîne libre (le xerboxion signe en RS, pas en nom de personne).
pub author: String,
/// Secondes depuis l'epoch Unix (fuseau figé `+0000`).
pub timestamp: u64,
/// Le message, restitué verbatim.
pub message: String,
}
/// Un dépôt bion-git : un répertoire de travail et son magasin `.bgit/`.
///
/// Layout sur disque (calqué sur git) :
///
/// ```text
/// .bgit/
/// HEAD → "ref: refs/heads/main\n"
/// objects/ab/cdef… → objets bruts (2 chars / 38 chars), NON compressés
/// refs/heads/<branche> → 40 hex + '\n'
/// ```
pub struct Repo {
bgit: PathBuf,
}
impl Repo {
/// Crée (ou réutilise) le magasin `.bgit/` dans `dir` et ouvre le dépôt.
///
/// Idempotent : ré-initialiser un dépôt existant ne détruit rien
/// (même contrat que `git init`).
pub fn init(dir: &Path) -> io::Result<Repo> {
let bgit = dir.join(".bgit");
fs::create_dir_all(bgit.join("objects"))?;
fs::create_dir_all(bgit.join("refs/heads"))?;
let head = bgit.join("HEAD");
if !head.exists() {
fs::write(&head, "ref: refs/heads/main\n")?;
}
Ok(Repo { bgit })
}
/// Ouvre un dépôt déjà initialisé ; `NotFound` si `dir/.bgit` n'existe pas.
pub fn open(dir: &Path) -> io::Result<Repo> {
let bgit = dir.join(".bgit");
if !bgit.join("objects").is_dir() {
return Err(io::Error::new(
io::ErrorKind::NotFound,
format!("pas de dépôt bion-git dans {}", dir.display()),
));
}
Ok(Repo { bgit })
}
/// Chemin de l'objet `id` : `objects/ab/cdef…` (2 caractères de
/// répertoire, 38 de fichier — pour ne pas entasser des millions de
/// fichiers dans un seul dossier).
fn object_path(&self, id: &Id) -> PathBuf {
let hex = id.to_hex();
self.bgit.join("objects").join(&hex[..2]).join(&hex[2..])
}
/// Hache `data` comme un objet de type `kind`, l'écrit dans le magasin
/// et rend son [`Id`] — l'équivalent de `git hash-object -w`.
///
/// Le hash porte sur `"{kind} {len}\0" + data` : c'est l'en-tête qui
/// fait qu'un blob vide et un tree vide ont des ids différents.
/// Écriture atomique (fichier temporaire puis `rename`) et idempotente :
/// si l'objet existe déjà, il est déjà correct par construction.
pub fn hash_object(&self, data: &[u8], kind: Kind) -> io::Result<Id> {
let mut obj = Vec::with_capacity(data.len() + 16);
obj.extend_from_slice(kind.as_str().as_bytes());
obj.push(b' ');
obj.extend_from_slice(data.len().to_string().as_bytes());
obj.push(0);
obj.extend_from_slice(data);
let id = Id(sha1::sha1(&obj));
let path = self.object_path(&id);
if !path.exists() {
fs::create_dir_all(path.parent().unwrap())?;
// Atomicité : jamais d'objet à moitié écrit visible sous son nom final.
let tmp = path.with_extension(format!("tmp{}", std::process::id()));
fs::write(&tmp, &obj)?;
fs::rename(&tmp, &path)?;
}
Ok(id)
}
/// Relit un objet : rend `(type, contenu)` — l'équivalent de
/// `git cat-file`.
///
/// Vérifie l'intégrité : le SHA-1 des octets lus doit redonner `id`
/// (un magasin content-addressed est *auto-vérifiant* — c'est le fsck
/// gratuit). `InvalidData` si l'objet est corrompu ou malformé.
pub fn cat_object(&self, id: &Id) -> io::Result<(Kind, Vec<u8>)> {
let obj = fs::read(self.object_path(id))?;
if Id(sha1::sha1(&obj)) != *id {
return Err(bad_data(format!(
"objet {id} corrompu : le hash ne correspond plus"
)));
}
let nul = obj
.iter()
.position(|&b| b == 0)
.ok_or_else(|| bad_data(format!("objet {id} : en-tête sans NUL")))?;
let header = &obj[..nul];
let space = header
.iter()
.position(|&b| b == b' ')
.ok_or_else(|| bad_data(format!("objet {id} : en-tête sans espace")))?;
let kind = Kind::from_bytes(&header[..space])?;
let len: usize = std::str::from_utf8(&header[space + 1..])
.ok()
.and_then(|s| s.parse().ok())
.ok_or_else(|| bad_data(format!("objet {id} : taille illisible")))?;
let data = obj[nul + 1..].to_vec();
if data.len() != len {
return Err(bad_data(format!(
"objet {id} : taille annoncée {len}, réelle {}",
data.len()
)));
}
Ok((kind, data))
}
// ------------------------------------------------------------------
// Trees : photographier et rematérialiser un répertoire
// ------------------------------------------------------------------
/// Photographie récursivement le répertoire `dir_snapshot` : chaque
/// fichier devient un blob, chaque répertoire un tree, et l'[`Id`] du
/// tree racine est rendu — l'équivalent de `git write-tree`, sans index.
///
/// Règles (celles de git) :
/// - `.bgit` est ignoré (le magasin ne se photographie pas lui-même) ;
/// - les répertoires vides ne produisent pas d'entrée (git ne suit pas
/// les dossiers vides) — sauf la racine, qui peut être le tree vide ;
/// - les entrées sont triées par octets du nom, les répertoires comptant
/// comme `nom + "/"` (la subtilité de tri qui garantit qu'un même
/// contenu donne toujours le même id, quel que soit l'ordre du FS) ;
/// - noms non-UTF-8 et types exotiques (symlinks…) → refus explicite.
pub fn write_tree(&self, dir_snapshot: &Path) -> io::Result<Id> {
self.write_tree_inner(dir_snapshot)
}
fn write_tree_inner(&self, dir: &Path) -> io::Result<Id> {
// (clé de tri, octets d'entrée) — la clé traite un répertoire comme "nom/".
let mut entries: Vec<(Vec<u8>, Vec<u8>)> = Vec::new();
for dirent in fs::read_dir(dir)? {
let dirent = dirent?;
let name = dirent
.file_name()
.into_string()
.map_err(|n| bad_data(format!("nom non-UTF-8 : {:?}", n)))?;
if name == ".bgit" {
continue;
}
let ftype = dirent.file_type()?;
let (mode, id, is_dir) = if ftype.is_dir() {
let sub = self.write_tree_inner(&dirent.path())?;
// Sous-répertoire vide → pas d'entrée (comme git).
let (_, data) = self.cat_object(&sub)?;
if data.is_empty() {
continue;
}
("40000", sub, true)
} else if ftype.is_file() {
let blob = self.hash_object(&fs::read(dirent.path())?, Kind::Blob)?;
("100644", blob, false)
} else {
return Err(bad_data(format!(
"type de fichier non géré (symlink ?) : {}",
dirent.path().display()
)));
};
let mut key = name.as_bytes().to_vec();
if is_dir {
key.push(b'/');
}
let mut raw = Vec::with_capacity(name.len() + 28);
raw.extend_from_slice(mode.as_bytes());
raw.push(b' ');
raw.extend_from_slice(name.as_bytes());
raw.push(0);
raw.extend_from_slice(&id.0);
entries.push((key, raw));
}
entries.sort_by(|a, b| a.0.cmp(&b.0));
let mut payload = Vec::new();
for (_, raw) in entries {
payload.extend_from_slice(&raw);
}
self.hash_object(&payload, Kind::Tree)
}
/// Décode un objet tree en ses entrées `(mode, nom, id)`.
pub fn read_tree(&self, id: &Id) -> io::Result<Vec<TreeEntry>> {
let (kind, data) = self.cat_object(id)?;
if kind != Kind::Tree {
return Err(bad_data(format!(
"{id} est un {}, pas un tree",
kind.as_str()
)));
}
let mut entries = Vec::new();
let mut rest = &data[..];
while !rest.is_empty() {
let space = rest
.iter()
.position(|&b| b == b' ')
.ok_or_else(|| bad_data(format!("tree {id} : entrée sans espace")))?;
let mode = std::str::from_utf8(&rest[..space])
.map_err(|_| bad_data(format!("tree {id} : mode non-UTF-8")))?
.to_string();
rest = &rest[space + 1..];
let nul = rest
.iter()
.position(|&b| b == 0)
.ok_or_else(|| bad_data(format!("tree {id} : entrée sans NUL")))?;
let name = std::str::from_utf8(&rest[..nul])
.map_err(|_| bad_data(format!("tree {id} : nom non-UTF-8")))?
.to_string();
rest = &rest[nul + 1..];
if rest.len() < 20 {
return Err(bad_data(format!("tree {id} : id tronqué")));
}
let mut oid = [0u8; 20];
oid.copy_from_slice(&rest[..20]);
rest = &rest[20..];
entries.push(TreeEntry {
mode,
name,
id: Id(oid),
});
}
Ok(entries)
}
/// Rematérialise le tree `id` dans le répertoire `dest` (créé si besoin) —
/// l'inverse de [`Repo::write_tree`], l'équivalent d'un checkout.
///
/// Sécurité : les noms d'entrée contenant `/`, `\`, `..`, `.` ou vides
/// sont refusés — un objet forgé ne peut pas écrire hors de `dest`.
pub fn checkout_tree(&self, id: &Id, dest: &Path) -> io::Result<()> {
fs::create_dir_all(dest)?;
for entry in self.read_tree(id)? {
if entry.name.is_empty()
|| entry.name == "."
|| entry.name == ".."
|| entry.name.contains('/')
|| entry.name.contains('\\')
{
return Err(bad_data(format!(
"nom d'entrée dangereux refusé : {:?}",
entry.name
)));
}
let path = dest.join(&entry.name);
match entry.mode.as_str() {
"40000" | "040000" => self.checkout_tree(&entry.id, &path)?,
_ => {
let (kind, data) = self.cat_object(&entry.id)?;
if kind != Kind::Blob {
return Err(bad_data(format!("{} n'est pas un blob", entry.id)));
}
fs::write(&path, data)?;
}
}
}
Ok(())
}
// ------------------------------------------------------------------
// Commits : chaîner les instantanés
// ------------------------------------------------------------------
/// Crée un commit daté de *maintenant*. Voir [`Repo::commit_at`].
pub fn commit(&self, tree: Id, parents: &[Id], msg: &str, author: &str) -> io::Result<Id> {
let now = SystemTime::now()
.duration_since(UNIX_EPOCH)
.map_err(|e| bad_data(format!("horloge avant l'epoch : {e}")))?
.as_secs();
self.commit_at(tree, parents, msg, author, now)
}
/// Crée un commit avec un horodatage explicite (secondes Unix) —
/// la variante **déterministe** : mêmes entrées → même [`Id`], toujours.
/// (Rejouabilité : la même vertu que les tsoins.)
///
/// Format textuel, calqué sur git :
///
/// ```text
/// tree <40 hex>
/// parent <40 hex> (une ligne par parent, dans l'ordre donné)
/// author <chaîne libre> <ts> +0000
/// committer <chaîne libre> <ts> +0000
///
/// <message verbatim>
/// ```
///
/// `author` ne doit pas contenir de saut de ligne (`InvalidInput` sinon) ;
/// le message, lui, peut être multi-lignes — il est restitué tel quel.
pub fn commit_at(
&self,
tree: Id,
parents: &[Id],
msg: &str,
author: &str,
timestamp: u64,
) -> io::Result<Id> {
if author.contains('\n') {
return Err(bad_input(
"l'auteur ne peut pas contenir de saut de ligne".into(),
));
}
let (kind, _) = self.cat_object(&tree)?;
if kind != Kind::Tree {
return Err(bad_input(format!(
"{tree} est un {}, pas un tree",
kind.as_str()
)));
}
let mut text = String::new();
text.push_str(&format!("tree {tree}\n"));
for p in parents {
text.push_str(&format!("parent {p}\n"));
}
text.push_str(&format!("author {author} {timestamp} +0000\n"));
text.push_str(&format!("committer {author} {timestamp} +0000\n"));
text.push('\n');
text.push_str(msg);
self.hash_object(text.as_bytes(), Kind::Commit)
}
/// Relit et décode un commit du magasin.
pub fn read_commit(&self, id: &Id) -> io::Result<Commit> {
let (kind, data) = self.cat_object(id)?;
if kind != Kind::Commit {
return Err(bad_data(format!(
"{id} est un {}, pas un commit",
kind.as_str()
)));
}
let text =
String::from_utf8(data).map_err(|_| bad_data(format!("commit {id} : non-UTF-8")))?;
let (header, message) = text
.split_once("\n\n")
.ok_or_else(|| bad_data(format!("commit {id} : pas de ligne vide avant le message")))?;
let mut tree = None;
let mut parents = Vec::new();
let mut author = None;
let mut timestamp = None;
for line in header.lines() {
if let Some(v) = line.strip_prefix("tree ") {
tree = Some(Id::from_hex(v)?);
} else if let Some(v) = line.strip_prefix("parent ") {
parents.push(Id::from_hex(v)?);
} else if let Some(v) = line.strip_prefix("author ") {
// "author <chaîne libre> <ts> +0000" → on détache les 2 derniers mots.
let no_tz = v
.rsplit_once(' ')
.ok_or_else(|| bad_data(format!("commit {id} : ligne author malformée")))?
.0;
let (name, ts) = no_tz
.rsplit_once(' ')
.ok_or_else(|| bad_data(format!("commit {id} : ligne author malformée")))?;
author = Some(name.to_string());
timestamp = Some(
ts.parse::<u64>()
.map_err(|_| bad_data(format!("commit {id} : timestamp illisible")))?,
);
}
// "committer" : redondant avec author dans ce bion, ignoré à la lecture.
}
Ok(Commit {
id: *id,
tree: tree.ok_or_else(|| bad_data(format!("commit {id} : pas de tree")))?,
parents,
author: author.ok_or_else(|| bad_data(format!("commit {id} : pas d'author")))?,
timestamp: timestamp.unwrap_or(0),
message: message.to_string(),
})
}
/// Remonte l'histoire depuis `from` en suivant le **premier parent** de
/// chaque commit, et rend la liste du plus récent au plus ancien —
/// l'équivalent de `git log --first-parent`.
///
/// (Suivre le premier parent suffit à raconter *une* ligne d'histoire ;
/// explorer tout le graphe d'un merge est laissé à l'appelant, qui a
/// `parents` sous la main.)
pub fn log(&self, from: Id) -> io::Result<Vec<Commit>> {
let mut out = Vec::new();
let mut cursor = Some(from);
let mut vus = std::collections::HashSet::new();
while let Some(id) = cursor {
if !vus.insert(id) {
return Err(bad_data(format!(
"cycle dans l'histoire à {id} (magasin corrompu)"
)));
}
let c = self.read_commit(&id)?;
cursor = c.parents.first().copied();
out.push(c);
}
Ok(out)
}
// ------------------------------------------------------------------
// Branches : des noms posés sur des commits
// ------------------------------------------------------------------
/// Pose (ou déplace) la branche `name` sur le commit `at`.
///
/// Une branche n'est *que ça* : 41 octets dans `refs/heads/<name>`.
/// C'est pourquoi forker est gratuit. Le nom doit rester simple
/// (alphanumérique, `-`, `_`, `.`) — pas de `/` ni de traversée.
pub fn branch(&self, name: &str, at: Id) -> io::Result<()> {
if name.is_empty()
|| !name
.chars()
.all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_' || c == '.')
|| name.starts_with('.')
{
return Err(bad_input(format!("nom de branche invalide : {name:?}")));
}
fs::write(self.bgit.join("refs/heads").join(name), format!("{at}\n"))
}
/// Lit l'[`Id`] pointé par la branche `name` ; `NotFound` si elle n'existe pas.
pub fn branch_target(&self, name: &str) -> io::Result<Id> {
let s = fs::read_to_string(self.bgit.join("refs/heads").join(name))?;
Id::from_hex(&s)
}
/// Liste les branches existantes, triées par nom.
pub fn branches(&self) -> io::Result<Vec<String>> {
let mut out: Vec<String> = fs::read_dir(self.bgit.join("refs/heads"))?
.filter_map(|e| e.ok()?.file_name().into_string().ok())
.collect();
out.sort();
Ok(out)
}
}
// ----------------------------------------------------------------------
// Tests
// ----------------------------------------------------------------------
#[cfg(test)]
mod tests {
use super::*;
use std::sync::atomic::{AtomicUsize, Ordering};
static COMPTEUR: AtomicUsize = AtomicUsize::new(0);
/// Un répertoire temporaire unique par test (std-only, pas de crate tempfile).
fn dir_temporaire() -> PathBuf {
let n = COMPTEUR.fetch_add(1, Ordering::SeqCst);
let d = std::env::temp_dir().join(format!("bion-git-test-{}-{}", std::process::id(), n));
fs::create_dir_all(&d).unwrap();
d
}
struct Nettoyeur(PathBuf);
impl Drop for Nettoyeur {
fn drop(&mut self) {
let _ = fs::remove_dir_all(&self.0);
}
}
fn repo_test() -> (Repo, PathBuf, Nettoyeur) {
let d = dir_temporaire();
let repo = Repo::init(&d).unwrap();
let gardien = Nettoyeur(d.clone());
(repo, d, gardien)
}
/// Nos identifiants de blobs et de trees sont EXACTEMENT ceux de git —
/// vecteurs bien connus (`git hash-object`, tree vide).
#[test]
fn ids_identiques_a_git() {
let (repo, _d, _g) = repo_test();
// blob vide
assert_eq!(
repo.hash_object(b"", Kind::Blob).unwrap().to_hex(),
"e69de29bb2d1d6434b8b29ae775ad8c2e48c5391"
);
// `echo "hello world" | git hash-object --stdin`
assert_eq!(
repo.hash_object(b"hello world\n", Kind::Blob)
.unwrap()
.to_hex(),
"3b18e512dba79e4c8300dd08aeb37f8e728b8dad"
);
// le tree vide, le plus célèbre des ids de git
assert_eq!(
repo.hash_object(b"", Kind::Tree).unwrap().to_hex(),
"4b825dc642cb6eb9a060e54bf8d69288fbee4904"
);
}
/// Le layout disque est bien objects/ab/cdef… (2 / 38).
#[test]
fn layout_objets_2_38() {
let (repo, d, _g) = repo_test();
let id = repo.hash_object(b"xerboxion", Kind::Blob).unwrap();
let hex = id.to_hex();
let chemin = d.join(".bgit/objects").join(&hex[..2]).join(&hex[2..]);
assert!(chemin.is_file(), "objet absent de {}", chemin.display());
assert_eq!(hex[..2].len(), 2);
assert_eq!(hex[2..].len(), 38);
}
/// Aller-retour blob : ce qu'on écrit est ce qu'on relit, type compris.
/// Et l'écriture est idempotente (déduplication par construction).
#[test]
fn roundtrip_blob() {
let (repo, _d, _g) = repo_test();
let data = b"contenu \x00 binaire \xff aussi".to_vec();
let id1 = repo.hash_object(&data, Kind::Blob).unwrap();
let id2 = repo.hash_object(&data, Kind::Blob).unwrap();
assert_eq!(id1, id2, "même contenu → même id (dédup)");
let (kind, relu) = repo.cat_object(&id1).unwrap();
assert_eq!(kind, Kind::Blob);
assert_eq!(relu, data);
}
/// Le magasin est auto-vérifiant : un objet corrompu sur disque est
/// détecté à la lecture (le hash ne correspond plus).
#[test]
fn corruption_detectee() {
let (repo, d, _g) = repo_test();
let id = repo.hash_object(b"important", Kind::Blob).unwrap();
let hex = id.to_hex();
let chemin = d.join(".bgit/objects").join(&hex[..2]).join(&hex[2..]);
fs::write(&chemin, b"blob 7\0sabotee").unwrap();
let err = repo.cat_object(&id).unwrap_err();
assert_eq!(err.kind(), io::ErrorKind::InvalidData);
}
/// Photographier un répertoire imbriqué puis le rematérialiser ailleurs :
/// contenu identique, et le même contenu redonne le même id de tree
/// (déterminisme, quel que soit l'ordre de création des fichiers).
#[test]
fn roundtrip_tree_imbrique() {
let (repo, d, _g) = repo_test();
let src = d.join("monde");
fs::create_dir_all(src.join("src/coeur")).unwrap();
fs::write(src.join("lisez-moi.txt"), "un bion = un cours\n").unwrap();
fs::write(src.join("src/main.rs"), "fn main() {}\n").unwrap();
fs::write(src.join("src/coeur/bion.rs"), "// cœur\n").unwrap();
fs::create_dir_all(src.join("vide")).unwrap(); // ignoré, comme git
let tree = repo.write_tree(&src).unwrap();
// Vecteur vérifié contre le VRAI git (`git write-tree` sur le même
// contenu) : nos trees sont bit-à-bit compatibles, tri compris.
assert_eq!(tree.to_hex(), "15c93b9663e95c58becfa3172ed753e14dbef718");
// Même contenu recréé dans un AUTRE ordre → même id.
let src2 = d.join("monde-bis");
fs::create_dir_all(src2.join("src/coeur")).unwrap();
fs::write(src2.join("src/coeur/bion.rs"), "// cœur\n").unwrap();
fs::write(src2.join("src/main.rs"), "fn main() {}\n").unwrap();
fs::write(src2.join("lisez-moi.txt"), "un bion = un cours\n").unwrap();
assert_eq!(
repo.write_tree(&src2).unwrap(),
tree,
"content-addressing : même monde, même nom"
);
let dest = d.join("restaure");
repo.checkout_tree(&tree, &dest).unwrap();
assert_eq!(
fs::read_to_string(dest.join("lisez-moi.txt")).unwrap(),
"un bion = un cours\n"
);
assert_eq!(
fs::read_to_string(dest.join("src/main.rs")).unwrap(),
"fn main() {}\n"
);
assert_eq!(
fs::read_to_string(dest.join("src/coeur/bion.rs")).unwrap(),
"// cœur\n"
);
assert!(
!dest.join("vide").exists(),
"les répertoires vides ne sont pas suivis"
);
assert!(
!dest.join(".bgit").exists(),
"le magasin ne se photographie pas lui-même"
);
}
/// Aller-retour commit : tous les champs se relisent exactement,
/// message multi-lignes compris. Et commit_at est déterministe.
#[test]
fn roundtrip_commit() {
let (repo, d, _g) = repo_test();
fs::write(d.join("a.txt"), "a").unwrap();
let tree = repo.write_tree(&d).unwrap();
let msg = "premier instant\n\navec un corps\nmulti-lignes";
let id = repo
.commit_at(tree, &[], msg, "rs-1 <rs1@xerboxion>", 1_755_300_000)
.unwrap();
let id_bis = repo
.commit_at(tree, &[], msg, "rs-1 <rs1@xerboxion>", 1_755_300_000)
.unwrap();
assert_eq!(id, id_bis, "commit_at est déterministe");
let c = repo.read_commit(&id).unwrap();
assert_eq!(c.id, id);
assert_eq!(c.tree, tree);
assert!(c.parents.is_empty());
assert_eq!(c.author, "rs-1 <rs1@xerboxion>");
assert_eq!(c.timestamp, 1_755_300_000);
assert_eq!(c.message, msg);
}
/// log d'une chaîne de trois commits : du plus récent au plus ancien.
#[test]
fn log_chaine() {
let (repo, d, _g) = repo_test();
fs::write(d.join("a.txt"), "v1").unwrap();
let t1 = repo.write_tree(&d).unwrap();
let c1 = repo.commit_at(t1, &[], "un", "rs-1", 100).unwrap();
fs::write(d.join("a.txt"), "v2").unwrap();
let t2 = repo.write_tree(&d).unwrap();
let c2 = repo.commit_at(t2, &[c1], "deux", "rs-1", 200).unwrap();
fs::write(d.join("a.txt"), "v3").unwrap();
let t3 = repo.write_tree(&d).unwrap();
let c3 = repo.commit_at(t3, &[c2], "trois", "rs-1", 300).unwrap();
let histoire = repo.log(c3).unwrap();
assert_eq!(histoire.len(), 3);
assert_eq!(
histoire
.iter()
.map(|c| c.message.as_str())
.collect::<Vec<_>>(),
["trois", "deux", "un"]
);
assert_eq!(histoire[2].parents, Vec::<Id>::new());
}
/// LE test du principe : deux branches qui divergent depuis un parent
/// commun — le fork VISIBLE. Les deux histoires partagent leur racine
/// sans copier un octet, et chaque branche se relit par son nom.
#[test]
fn fork_deux_branches_divergentes() {
let (repo, d, _g) = repo_test();
fs::write(d.join("monde.txt"), "commun").unwrap();
let racine_tree = repo.write_tree(&d).unwrap();
let racine = repo
.commit_at(racine_tree, &[], "racine", "rs-1", 100)
.unwrap();
// Branche main : le chemin d'origine continue.
fs::write(d.join("monde.txt"), "chemin main").unwrap();
let tm = repo.write_tree(&d).unwrap();
let cm = repo
.commit_at(tm, &[racine], "suite sur main", "rs-1", 200)
.unwrap();
repo.branch("main", cm).unwrap();
// Branche fork : la bifurcation, depuis LE MÊME parent.
fs::write(d.join("monde.txt"), "chemin fork").unwrap();
let tf = repo.write_tree(&d).unwrap();
let cf = repo
.commit_at(tf, &[racine], "bifurcation", "rs-7", 200)
.unwrap();
repo.branch("fork", cf).unwrap();
assert_ne!(
cm, cf,
"deux contenus, deux ids : la divergence est visible"
);
assert_eq!(repo.branch_target("main").unwrap(), cm);
assert_eq!(repo.branch_target("fork").unwrap(), cf);
assert_eq!(repo.branches().unwrap(), ["fork", "main"]);
// Les deux histoires convergent (en remontant) vers la même racine.
let log_main = repo.log(repo.branch_target("main").unwrap()).unwrap();
let log_fork = repo.log(repo.branch_target("fork").unwrap()).unwrap();
assert_eq!(log_main.last().unwrap().id, racine);
assert_eq!(log_fork.last().unwrap().id, racine);
// …et le passé commun n'est stocké qu'une fois : même objet racine.
assert_eq!(log_main.last().unwrap(), log_fork.last().unwrap());
}
/// Un merge est représentable : un commit à deux parents, que log
/// remonte par son premier parent.
#[test]
fn merge_deux_parents() {
let (repo, d, _g) = repo_test();
fs::write(d.join("x"), "0").unwrap();
let t0 = repo.write_tree(&d).unwrap();
let racine = repo.commit_at(t0, &[], "racine", "rs-1", 1).unwrap();
let a = repo.commit_at(t0, &[racine], "a", "rs-1", 2).unwrap();
let b = repo.commit_at(t0, &[racine], "b", "rs-7", 2).unwrap();
let m = repo
.commit_at(t0, &[a, b], "retrouvailles", "rs-1", 3)
.unwrap();
let c = repo.read_commit(&m).unwrap();
assert_eq!(c.parents, vec![a, b]);
let histoire = repo.log(m).unwrap();
assert_eq!(
histoire
.iter()
.map(|c| c.message.as_str())
.collect::<Vec<_>>(),
["retrouvailles", "a", "racine"]
);
}
/// Cas limites d'Id : parsing hex strict, aller-retour Display/FromStr.
#[test]
fn id_hex_cas_limites() {
assert!(Id::from_hex("abc").is_err(), "trop court");
assert!(Id::from_hex(&"z".repeat(40)).is_err(), "non-hex");
let id = Id::from_hex("4b825dc642cb6eb9a060e54bf8d69288fbee4904").unwrap();
assert_eq!(id.to_string().parse::<Id>().unwrap(), id);
// Les majuscules sont acceptées en entrée, normalisées en sortie.
let maj = Id::from_hex("4B825DC642CB6EB9A060E54BF8D69288FBEE4904").unwrap();
assert_eq!(maj, id);
}
/// Erreurs propres : objet inconnu, mauvais type au commit,
/// branche au nom dangereux, dépôt inexistant.
#[test]
fn erreurs_propres() {
let (repo, d, _g) = repo_test();
let fantome = Id([0u8; 20]);
assert_eq!(
repo.cat_object(&fantome).unwrap_err().kind(),
io::ErrorKind::NotFound
);
assert!(repo.checkout_tree(&fantome, &d.join("nulle-part")).is_err());
// Un commit doit pointer un tree, pas un blob.
let blob = repo.hash_object(b"x", Kind::Blob).unwrap();
assert!(repo.commit(blob, &[], "m", "rs-1").is_err());
// Pas de traversée par le nom de branche.
let tree = repo.hash_object(b"", Kind::Tree).unwrap();
let c = repo.commit_at(tree, &[], "m", "rs-1", 1).unwrap();
assert!(repo.branch("../evasion", c).is_err());
assert!(repo.branch("a/b", c).is_err());
assert!(repo.branch("", c).is_err());
assert!(repo.branch_target("inconnue").is_err());
// open() exige un dépôt initialisé.
assert!(Repo::open(&d.join("pas-un-depot")).is_err());
}
/// L'auteur ne peut pas casser le format textuel du commit
/// (injection de ligne « parent » via un \n).
#[test]
fn auteur_sans_injection() {
let (repo, _d, _g) = repo_test();
let tree = repo.hash_object(b"", Kind::Tree).unwrap();
let e = repo
.commit_at(tree, &[], "m", "rs-1\nparent 0000", 1)
.unwrap_err();
assert_eq!(e.kind(), io::ErrorKind::InvalidInput);
}
}