thin-fetch 0.1.0

Low-level Git crate to fetch objects with high granularity
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use std::collections::{HashMap, HashSet};

use crate::object::{Commit, Object, Tree};
use crate::{Error, WithError as _, bail, error};

/// Commit reference with all entries collected from the repo.
#[derive(Debug)]
pub struct Checkout<'a> {
    pub commit: &'a Commit,
    pub entries: HashMap<String, DirEntry<'a>>,
}

impl<'a> Checkout<'a> {
    /// Collect checkout from a repository of objects.
    ///
    /// # Errors
    ///
    /// Returns an error when an object cannot be found.
    pub fn from_pack(pack: &'a HashMap<String, Object>, oid: &str) -> Result<Self, Error> {
        let commit_obj = pack
            .get(oid)
            .with_err(|| error!("commit {oid} not found"))?;

        let Object::Commit(commit) = commit_obj else {
            bail!("expected {oid} to be a commit, got {commit_obj:?}")
        };

        let tree_id = commit.commit.tree.to_string();

        let tree_obj = pack
            .get(&tree_id)
            .with_err(|| error!("root tree {tree_id} not found"))?;

        let mut entries = HashMap::new();

        let Object::Tree(tree) = tree_obj else {
            bail!("expected {tree_id} to be a tree, got {tree_obj:?}")
        };

        collect_entries(pack, tree, ".", &mut entries);

        Ok(Self { commit, entries })
    }

    /// Get difference between checkouts.
    #[must_use]
    pub fn get_diff(&self, other: &Checkout) -> Vec<BlobDiff> {
        let all_paths = self
            .entries
            .values()
            .chain(other.entries.values())
            .filter(|entry| !entry.dir)
            .map(|entry| entry.path.as_str())
            .collect::<HashSet<&str>>();

        let mut result = vec![];

        for path in all_paths {
            let this = self.entries.get(path);
            let other = other.entries.get(path);

            if this != other {
                let old = other.map(|a| a.hash.clone());
                let new = this.map(|a| a.hash.clone());

                result.push(BlobDiff {
                    path: path.to_owned(),
                    old_oid: old,
                    new_oid: new,
                });
            }
        }

        result.sort_by(|a, b| a.path.cmp(&b.path));

        result
    }
}

fn collect_entries<'a>(
    pack: &'a HashMap<String, Object>,
    tree: &'a Tree,
    path: &str,
    entries: &mut HashMap<String, DirEntry<'a>>,
) {
    for entry in &tree.entries {
        let hash = &entry.hash;
        let path = format!("{path}/{}", entry.name);

        let object = pack.get(hash);

        if let Some(Object::Tree(tree)) = object {
            collect_entries(pack, tree, &path, entries);
        }

        entries.insert(
            path.clone(),
            DirEntry {
                path,
                hash: hash.clone(),
                dir: entry.is_dir(),
                object,
            },
        );
    }
}

#[derive(Debug, Clone)]
pub struct BlobDiff {
    pub path: String,

    pub old_oid: Option<String>,
    pub new_oid: Option<String>,
}

#[derive(Debug, Clone)]
pub struct DirEntry<'a> {
    pub path: String,
    pub hash: String,
    pub dir: bool,
    pub object: Option<&'a Object>,
}

impl PartialEq<DirEntry<'_>> for DirEntry<'_> {
    fn eq(&self, other: &DirEntry) -> bool {
        self.path == other.path && self.hash == other.hash
    }
}