git-async 0.1.1

An async-first library for reading git repositories
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

use crate::{
    error::{GResult, annotate_with_object_id},
    file_system::{Directory, FileSystem, Offset},
    object::ObjectId,
    object_store::{
        ObjectSize, ObjectType, RawObject,
        cache::IndexCache,
        index::{FanoutTable, ShortOffsetTable, find_object_in_pack_index},
        loose::{read_loose_object, read_loose_object_size_type},
        pack::{form_deltified_chain, reconstruct_deltified_object_from_chain},
        page_read::CachingPageReader,
    },
    repo::Repo,
};
use alloc::vec::Vec;

#[derive(Clone)]
pub(crate) struct PackName {
    pub(crate) index_filename: Vec<u8>,
    pub(crate) pack_filename: Vec<u8>,
}

impl PackName {
    pub(crate) fn new(filename: Vec<u8>) -> Option<Self> {
        let stripped = filename.strip_suffix(b".idx")?;
        let mut pack_filename = Vec::with_capacity(filename.len() + 1);
        pack_filename.extend_from_slice(stripped);
        pack_filename.extend_from_slice(b".pack");
        Some(Self {
            index_filename: filename,
            pack_filename,
        })
    }
}

pub(crate) struct IndexedPackFile<'f, F> {
    pub(crate) index: CachingPageReader<F>,
    pub(crate) fanout: &'f FanoutTable,
    pub(crate) offsets: Option<&'f ShortOffsetTable>,
    pub(crate) pack: CachingPageReader<F>,
}

pub(crate) async fn lookup_size_type<F: FileSystem>(
    repo: &Repo<F>,
    id: ObjectId,
) -> GResult<Option<(ObjectSize, ObjectType)>> {
    let opt_size_type = read_loose_object_size_type(repo, id).await?;
    if opt_size_type.is_some() {
        return Ok(opt_size_type);
    }
    let pack_cache = &repo.index_cache;
    let Some((mut pack, offset)) = find_packed_object(repo, pack_cache, id).await? else {
        return Ok(None);
    };
    let (_, object_type, final_object) = form_deltified_chain(&mut pack, offset)
        .await
        .map_err(annotate_with_object_id(id))?;
    Ok(Some((final_object.size, object_type)))
}

pub(crate) async fn lookup<F: FileSystem>(
    repo: &Repo<F>,
    id: ObjectId,
) -> GResult<Option<RawObject>> {
    let loose_object = read_loose_object(repo, id).await?;
    if loose_object.is_some() {
        return Ok(loose_object);
    }
    let pack_cache = &repo.index_cache;
    let Some((mut indexed_pack, offset)) = find_packed_object(repo, pack_cache, id).await? else {
        return Ok(None);
    };
    let (chain, object_type, final_object) = form_deltified_chain(&mut indexed_pack, offset)
        .await
        .map_err(annotate_with_object_id(id))?;
    let body = reconstruct_deltified_object_from_chain(&mut indexed_pack, &chain, &final_object)
        .await
        .map_err(annotate_with_object_id(id))?;
    Ok(Some(RawObject { object_type, body }))
}

pub(crate) async fn find_packed_object<'p, F: FileSystem>(
    repo: &Repo<F>,
    pack_cache: &'p IndexCache,
    id: ObjectId,
) -> GResult<Option<(IndexedPackFile<'p, F::File>, Offset)>> {
    for (pack_meta, fanout, offsets) in &pack_cache.indexes {
        let idx_file = repo.pack_dir.open_file(&pack_meta.index_filename).await?;
        let mut idx_file = CachingPageReader::new(idx_file);
        if let Some(offset) =
            find_object_in_pack_index(fanout, offsets.as_ref(), &mut idx_file, id).await?
        {
            let pack_file = repo.pack_dir.open_file(&pack_meta.pack_filename).await?;
            return Ok(Some((
                IndexedPackFile {
                    fanout,
                    offsets: offsets.as_ref(),
                    index: idx_file,
                    pack: CachingPageReader::new(pack_file),
                },
                offset,
            )));
        }
    }
    Ok(None)
}