Tu propio Git mínimo en Rust: objetos, hashes, commits y log

cargo run -- init
cargo run -- hash nota.txt
cargo run -- write nota.txt
cargo run -- show <hash>
cargo run -- commit nota.txt -m "primer commit"
cargo run -- log

archivo
  ↓
bytes exactos
  ↓
objeto blob
  ↓
SHA-1
  ↓
.minigit/objects/<hash>
  ↓
commit
  ↓
.minigit/refs/heads/main
  ↓
log

No vamos a construir todavía:

- ramas reales
- merge
- diff
- checkout completo
- staging avanzado
- tags
- repositorios remotos
- packfiles
- compresión de objetos
- resolución de conflictos
- árboles de directorios completos

MiniGit en este tutorial:

commit
  ↓
blob


Git real:

commit
  ↓
tree
  ↓
blobs

mi_proyecto/
mi_proyecto_v1/
mi_proyecto_v2/
mi_proyecto_final/
mi_proyecto_final_final/
mi_proyecto_final_final_ahora_si/

blob <tamaño>\0<contenido>

blob 10\0hola mundo

hola mundo      -> 10 bytes
hola mundo\n    -> 11 bytes

printf "hola mundo" > nota.txt

[System.IO.File]::WriteAllBytes("nota.txt", [System.Text.Encoding]::UTF8.GetBytes("hola mundo"))

blob <tamaño>\0<contenido>

cargo new minigit

cd minigit

cargo run

Compiling minigit v0.1.0
Finished `dev` profile [unoptimized + debuginfo] target(s)
Running `target/debug/minigit`

Hello, world!

minigit/
├── Cargo.toml
└── src/
    └── main.rs

[package]
name = "minigit"
version = "0.1.0"
edition = "2024"

[dependencies]
sha1 = "0.10"
chrono = "0.4"

mod commands;
mod commit;
mod objects;
mod repository;

pub type AppResult<T> = Result<T, Box<dyn std::error::Error>>;

fn main() {
    if let Err(error) = commands::run() {
        eprintln!("Error: {error}");
        std::process::exit(1);
    }
}

pub type AppResult<T> = Result<T, Box<dyn std::error::Error>>;

use std::env;

use crate::AppResult;
use crate::commit;
use crate::objects;
use crate::repository;

pub fn run() -> AppResult<()> {
    let args: Vec<String> = env::args().collect();

    if args.len() < 2 {
        print_help();
        return Ok(());
    }

    match args[1].as_str() {
        "init" => {
            repository::init_repo()?;
        }

        "hash" => {
            if args.len() < 3 {
                return Err("Uso: minigit hash <archivo>".into());
            }

            let file_path = &args[2];
            let hash = objects::hash_file_as_git_blob(file_path)?;

            println!("{hash}");
        }

        "write" => {
            if args.len() < 3 {
                return Err("Uso: minigit write <archivo>".into());
            }

            let file_path = &args[2];
            let hash = objects::write_file_as_git_blob(file_path)?;

            println!("Objeto guardado: {hash}");
        }

        "show" => {
            if args.len() < 3 {
                return Err("Uso: minigit show <hash>".into());
            }

            let hash = &args[2];
            objects::show_object(hash)?;
        }

        "commit" => {
            if args.len() < 5 {
                return Err("Uso: minigit commit <archivo> -m \"mensaje\"".into());
            }

            let file_path = &args[2];

            if args[3] != "-m" {
                return Err("Uso: minigit commit <archivo> -m \"mensaje\"".into());
            }

            let message = args[4..].join(" ");

            if message.trim().is_empty() {
                return Err("El mensaje del commit no puede estar vacío".into());
            }

            let commit_hash = commit::commit_file(file_path, &message)?;

            println!("Commit creado: {commit_hash}");
        }

        "log" => {
            commit::log_commits()?;
        }

        "help" | "-h" | "--help" => {
            print_help();
        }

        command => {
            return Err(format!("Comando desconocido: {command}").into());
        }
    }

    Ok(())
}

fn print_help() {
    println!("minigit - un git mínimo escrito en Rust");
    println!();
    println!("Uso:");
    println!("  minigit <comando>");
    println!();
    println!("Comandos disponibles:");
    println!("  init                         Crea un repositorio .minigit");
    println!("  hash <archivo>               Calcula el hash tipo Git de un archivo");
    println!("  write <archivo>              Guarda un objeto blob en .minigit/objects");
    println!("  show <hash>                  Muestra el contenido de un objeto blob");
    println!("  commit <archivo> -m \"msg\"    Crea un commit mínimo apuntando a un blob");
    println!("  log                          Muestra el historial de commits");
}

let args: Vec<String> = env::args().collect();

if args.len() < 2 {
    print_help();
    return Ok(());
}

match args[1].as_str() {
    "init" => {
        repository::init_repo()?;
    }

    command => {
        return Err(format!("Comando desconocido: {command}").into());
    }
}

init
hash <archivo>
write <archivo>
show <hash>
commit <archivo> -m "mensaje"
log
help
-h
--help

let message = args[4..].join(" ");

if message.trim().is_empty() {
    return Err("El mensaje del commit no puede estar vacío".into());
}

.minigit/
├── HEAD
├── objects/
└── refs/
    └── heads/
        └── main

use std::fs;
use std::path::{Path, PathBuf};

use crate::AppResult;
use crate::objects;

pub const REPO_DIR: &str = ".minigit";

pub fn init_repo() -> AppResult<()> {
    let repo_path = Path::new(REPO_DIR);

    let objects_path = repo_path.join("objects");
    let refs_heads_path = repo_path.join("refs").join("heads");
    let head_path = repo_path.join("HEAD");
    let main_ref_path = refs_heads_path.join("main");

    fs::create_dir_all(&objects_path)?;
    fs::create_dir_all(&refs_heads_path)?;

    if !head_path.exists() {
        fs::write(&head_path, "ref: refs/heads/main\n")?;
    }

    if !main_ref_path.exists() {
        fs::write(&main_ref_path, "")?;
    }

    println!("Repositorio .minigit creado correctamente.");
    println!("HEAD -> refs/heads/main");

    Ok(())
}

pub fn ensure_repo_initialized() -> AppResult<()> {
    let repo_path = Path::new(REPO_DIR);
    let objects_path = repo_path.join("objects");
    let refs_heads_path = repo_path.join("refs").join("heads");
    let head_path = repo_path.join("HEAD");
    let main_ref_path = refs_heads_path.join("main");

    if !repo_path.exists()
        || !objects_path.exists()
        || !refs_heads_path.exists()
        || !head_path.exists()
    {
        return Err(
            "No estás dentro de un repositorio .minigit. Ejecuta primero: cargo run -- init".into(),
        );
    }

    if !main_ref_path.exists() {
        fs::write(main_ref_path, "")?;
    }

    Ok(())
}

pub fn object_path_from_hash(hash: &str) -> PathBuf {
    Path::new(REPO_DIR).join("objects").join(hash)
}

pub fn main_ref_path() -> PathBuf {
    Path::new(REPO_DIR).join("refs").join("heads").join("main")
}

pub fn read_current_head_hash() -> AppResult<Option<String>> {
    let main_ref_path = main_ref_path();

    if !main_ref_path.exists() {
        return Ok(None);
    }

    let content = fs::read_to_string(main_ref_path)?;
    let hash = content.trim();

    if hash.is_empty() {
        Ok(None)
    } else {
        objects::validate_hash(hash)?;
        Ok(Some(hash.to_string()))
    }
}

pub fn update_current_head(commit_hash: &str) -> AppResult<()> {
    objects::validate_hash(commit_hash)?;

    let main_ref_path = main_ref_path();

    fs::write(main_ref_path, format!("{commit_hash}\n"))?;

    Ok(())
}

pub const REPO_DIR: &str = ".minigit";

let repo_path = Path::new(REPO_DIR);

let objects_path = repo_path.join("objects");
let refs_heads_path = repo_path.join("refs").join("heads");
let head_path = repo_path.join("HEAD");
let main_ref_path = refs_heads_path.join("main");

fs::create_dir_all(&objects_path)?;
fs::create_dir_all(&refs_heads_path)?;

if !head_path.exists() {
    fs::write(&head_path, "ref: refs/heads/main\n")?;
}

if !main_ref_path.exists() {
    fs::write(&main_ref_path, "")?;
}

if !repo_path.exists()
    || !objects_path.exists()
    || !refs_heads_path.exists()
    || !head_path.exists()
{
    return Err(
        "No estás dentro de un repositorio .minigit. Ejecuta primero: cargo run -- init".into(),
    );
}

pub fn object_path_from_hash(hash: &str) -> PathBuf {
    Path::new(REPO_DIR).join("objects").join(hash)
}

.minigit/objects/<hash>

pub fn main_ref_path() -> PathBuf {
    Path::new(REPO_DIR).join("refs").join("heads").join("main")
}

pub fn read_current_head_hash() -> AppResult<Option<String>> {
    let main_ref_path = main_ref_path();

    if !main_ref_path.exists() {
        return Ok(None);
    }

    let content = fs::read_to_string(main_ref_path)?;
    let hash = content.trim();

    if hash.is_empty() {
        Ok(None)
    } else {
        objects::validate_hash(hash)?;
        Ok(Some(hash.to_string()))
    }
}

pub fn update_current_head(commit_hash: &str) -> AppResult<()> {
    objects::validate_hash(commit_hash)?;

    let main_ref_path = main_ref_path();

    fs::write(main_ref_path, format!("{commit_hash}\n"))?;

    Ok(())
}

refs/heads/main
  ↓
último commit

archivo
  ↓
bytes exactos
  ↓
blob <tamaño>\0<contenido>
  ↓
SHA-1
  ↓
.minigit/objects/<hash>

use sha1::{Digest, Sha1};
use std::fs;
use std::io::{self, Write};

use crate::AppResult;
use crate::repository;

pub fn hash_file_as_git_blob(file_path: &str) -> AppResult<String> {
    let content = fs::read(file_path)?;

    let object = build_blob_object(&content);
    let hash = sha1_hex(&object);

    Ok(hash)
}

pub fn write_file_as_git_blob(file_path: &str) -> AppResult<String> {
    repository::ensure_repo_initialized()?;

    let content = fs::read(file_path)?;

    let object = build_blob_object(&content);
    let hash = sha1_hex(&object);

    let object_path = repository::object_path_from_hash(&hash);

    if !object_path.exists() {
        fs::write(&object_path, object)?;
    }

    Ok(hash)
}

pub fn show_object(hash: &str) -> AppResult<()> {
    repository::ensure_repo_initialized()?;
    validate_hash(hash)?;

    let object_path = repository::object_path_from_hash(hash);

    if !object_path.exists() {
        return Err(format!("El objeto no existe: {hash}").into());
    }

    let object = fs::read(object_path)?;

    let (object_type, size, content) = parse_object(&object)?;

    if object_type != "blob" {
        return Err(format!("Tipo de objeto no soportado por show todavía: {object_type}").into());
    }

    if content.len() != size {
        return Err(format!(
            "Objeto corrupto: la cabecera dice {size} bytes, pero el contenido tiene {} bytes",
            content.len()
        )
        .into());
    }

    let mut stdout = io::stdout();
    stdout.write_all(content)?;
    stdout.flush()?;

    Ok(())
}

pub(crate) fn build_blob_object(content: &[u8]) -> Vec<u8> {
    build_object("blob", content)
}

pub(crate) fn build_object(object_type: &str, content: &[u8]) -> Vec<u8> {
    let header = format!("{object_type} {}\0", content.len());

    let mut object = Vec::new();
    object.extend_from_slice(header.as_bytes());
    object.extend_from_slice(content);

    object
}

pub(crate) fn parse_object(object: &[u8]) -> AppResult<(&str, usize, &[u8])> {
    let separator_position = object
        .iter()
        .position(|byte| *byte == 0)
        .ok_or("Objeto corrupto: no tiene separador \\0")?;

    let header_bytes = &object[..separator_position];
    let content = &object[separator_position + 1..];

    let header = std::str::from_utf8(header_bytes)?;

    let mut parts = header.split(' ');

    let object_type = parts
        .next()
        .ok_or("Objeto corrupto: falta el tipo de objeto")?;

    let size_text = parts
        .next()
        .ok_or("Objeto corrupto: falta el tamaño del objeto")?;

    if parts.next().is_some() {
        return Err("Objeto corrupto: la cabecera tiene demasiadas partes".into());
    }

    let size: usize = size_text.parse()?;

    Ok((object_type, size, content))
}

pub(crate) fn sha1_hex(bytes: &[u8]) -> String {
    let mut hasher = Sha1::new();
    hasher.update(bytes);

    let result = hasher.finalize();

    result.iter().map(|byte| format!("{byte:02x}")).collect()
}

pub(crate) fn validate_hash(hash: &str) -> AppResult<()> {
    if hash.len() != 40 {
        return Err("El hash debe tener 40 caracteres hexadecimales".into());
    }

    if !hash.chars().all(|character| character.is_ascii_hexdigit()) {
        return Err("El hash solo puede contener caracteres hexadecimales".into());
    }

    Ok(())
}

pub fn hash_file_as_git_blob(file_path: &str) -> AppResult<String> {
    let content = fs::read(file_path)?;

    let object = build_blob_object(&content);
    let hash = sha1_hex(&object);

    Ok(hash)
}

blob <tamaño>\0<contenido>

pub fn write_file_as_git_blob(file_path: &str) -> AppResult<String> {
    repository::ensure_repo_initialized()?;

    let content = fs::read(file_path)?;

    let object = build_blob_object(&content);
    let hash = sha1_hex(&object);

    let object_path = repository::object_path_from_hash(&hash);

    if !object_path.exists() {
        fs::write(&object_path, object)?;
    }

    Ok(hash)
}

repository::ensure_repo_initialized()?;

let content = fs::read(file_path)?;

let object = build_blob_object(&content);
let hash = sha1_hex(&object);

let object_path = repository::object_path_from_hash(&hash);

if !object_path.exists() {
    fs::write(&object_path, object)?;
}

pub fn show_object(hash: &str) -> AppResult<()> {
    repository::ensure_repo_initialized()?;
    validate_hash(hash)?;

    let object_path = repository::object_path_from_hash(hash);

    if !object_path.exists() {
        return Err(format!("El objeto no existe: {hash}").into());
    }

    let object = fs::read(object_path)?;

    let (object_type, size, content) = parse_object(&object)?;

    if object_type != "blob" {
        return Err(format!("Tipo de objeto no soportado por show todavía: {object_type}").into());
    }

    if content.len() != size {
        return Err(format!(
            "Objeto corrupto: la cabecera dice {size} bytes, pero el contenido tiene {} bytes",
            content.len()
        )
        .into());
    }

    let mut stdout = io::stdout();
    stdout.write_all(content)?;
    stdout.flush()?;

    Ok(())
}

repository::ensure_repo_initialized()?;
validate_hash(hash)?;

let object_path = repository::object_path_from_hash(hash);

if !object_path.exists() {
    return Err(format!("El objeto no existe: {hash}").into());
}

let object = fs::read(object_path)?;

let (object_type, size, content) = parse_object(&object)?;

if object_type != "blob" {
    return Err(format!("Tipo de objeto no soportado por show todavía: {object_type}").into());
}

if content.len() != size {
    return Err(format!(
        "Objeto corrupto: la cabecera dice {size} bytes, pero el contenido tiene {} bytes",
        content.len()
    )
    .into());
}

let mut stdout = io::stdout();
stdout.write_all(content)?;
stdout.flush()?;

pub(crate) fn build_blob_object(content: &[u8]) -> Vec<u8> {
    build_object("blob", content)
}

pub(crate) fn build_object(object_type: &str, content: &[u8]) -> Vec<u8> {
    let header = format!("{object_type} {}\0", content.len());

    let mut object = Vec::new();
    object.extend_from_slice(header.as_bytes());
    object.extend_from_slice(content);

    object
}

let header = format!("{object_type} {}\0", content.len());

blob 10\0

blob 10\0hola mundo

pub(crate) fn parse_object(object: &[u8]) -> AppResult<(&str, usize, &[u8])> {
    let separator_position = object
        .iter()
        .position(|byte| *byte == 0)
        .ok_or("Objeto corrupto: no tiene separador \\0")?;

    let header_bytes = &object[..separator_position];
    let content = &object[separator_position + 1..];

    let header = std::str::from_utf8(header_bytes)?;

    let mut parts = header.split(' ');

    let object_type = parts
        .next()
        .ok_or("Objeto corrupto: falta el tipo de objeto")?;

    let size_text = parts
        .next()
        .ok_or("Objeto corrupto: falta el tamaño del objeto")?;

    if parts.next().is_some() {
        return Err("Objeto corrupto: la cabecera tiene demasiadas partes".into());
    }

    let size: usize = size_text.parse()?;

    Ok((object_type, size, content))
}

let separator_position = object
    .iter()
    .position(|byte| *byte == 0)
    .ok_or("Objeto corrupto: no tiene separador \\0")?;

let header_bytes = &object[..separator_position];
let content = &object[separator_position + 1..];

let header = std::str::from_utf8(header_bytes)?;

let mut parts = header.split(' ');

let object_type = parts
    .next()
    .ok_or("Objeto corrupto: falta el tipo de objeto")?;

let size_text = parts
    .next()
    .ok_or("Objeto corrupto: falta el tamaño del objeto")?;

if parts.next().is_some() {
    return Err("Objeto corrupto: la cabecera tiene demasiadas partes".into());
}

let size: usize = size_text.parse()?;

Ok((object_type, size, content))

pub(crate) fn sha1_hex(bytes: &[u8]) -> String {
    let mut hasher = Sha1::new();
    hasher.update(bytes);

    let result = hasher.finalize();

    result.iter().map(|byte| format!("{byte:02x}")).collect()
}

let mut hasher = Sha1::new();
hasher.update(bytes);

let result = hasher.finalize();

result.iter().map(|byte| format!("{byte:02x}")).collect()

pub(crate) fn validate_hash(hash: &str) -> AppResult<()> {
    if hash.len() != 40 {
        return Err("El hash debe tener 40 caracteres hexadecimales".into());
    }

    if !hash.chars().all(|character| character.is_ascii_hexdigit()) {
        return Err("El hash solo puede contener caracteres hexadecimales".into());
    }

    Ok(())
}

if hash.len() != 40 {
    return Err("El hash debe tener 40 caracteres hexadecimales".into());
}

if !hash.chars().all(|character| character.is_ascii_hexdigit()) {
    return Err("El hash solo puede contener caracteres hexadecimales".into());
}

archivo
  ↓
fs::read()
  ↓
build_blob_object()
  ↓
sha1_hex()
  ↓
.minigit/objects/<hash>
  ↓
show_object()
  ↓
contenido original

use crate::AppResult;

pub fn commit_file(_file_path: &str, _message: &str) -> AppResult<String> {
    Err("El comando commit todavía no está implementado.".into())
}

pub fn log_commits() -> AppResult<()> {
    println!("El comando log todavía no está implementado.");
    Ok(())
}

cargo run -- init

Repositorio .minigit creado correctamente.
HEAD -> refs/heads/main

.minigit/
├── HEAD
├── objects/
└── refs/
    └── heads/
        └── main

ref: refs/heads/main

refs/heads/main
  ↓
vacío por ahora

init
  ↓
crea .minigit
  ↓
prepara objects/
  ↓
crea HEAD
  ↓
prepara refs/heads/main

[System.IO.File]::WriteAllBytes("nota.txt", [System.Text.Encoding]::UTF8.GetBytes("hola mundo"))

printf "hola mundo" > nota.txt

hola mundo

cargo run -- hash nota.txt

30364d155645e66aa59165e5df8e5f9ca8c6eecd

git hash-object nota.txt

30364d155645e66aa59165e5df8e5f9ca8c6eecd

blob 10\0hola mundo
  ↓
SHA-1
  ↓
30364d155645e66aa59165e5df8e5f9ca8c6eecd

hola mundo      -> hash esperado
hola mundo\n    -> otro hash diferente

hola mundo

cargo run -- write nota.txt

Objeto guardado: 30364d155645e66aa59165e5df8e5f9ca8c6eecd

.minigit/objects/30364d155645e66aa59165e5df8e5f9ca8c6eecd

Get-ChildItem .minigit\objects

ls .minigit/objects