libvctrl 0.5.1

A robust, content-addressed version control engine for arbitrary data, designed for embedding into applications.
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

use crate::command::Command;
use crate::domain::hash::Hash;
use crate::error::VctrlError;
use crate::storage::traits::{ObjectStore, ObjectStoreExt, RefStore};
use std::collections::HashSet;

const MAX_BLAME_ITERATIONS: usize = 100_000;

#[derive(Debug, Clone)]
pub struct BlameEntry {
    pub commit_hash: Hash,
    pub blob_hash: Hash,
    pub author: crate::domain::user::UserID,
    pub message: String,
}

pub struct Annotate {
    pub start_commit: Hash,
    pub path: String,
}

impl Command for Annotate {
    type Output = Vec<BlameEntry>;

    fn execute(
        &self,
        store: &mut dyn ObjectStore,
        _refs: &mut dyn RefStore,
    ) -> Result<Vec<BlameEntry>, VctrlError> {
        if self.path.is_empty() {
            return Err(VctrlError::Other("empty path".into()));
        }

        let mut result = Vec::new();
        let mut visited = HashSet::new();
        let mut current = Some(self.start_commit);
        let mut iterations = 0;

        let start_commit = store.get_commit(&self.start_commit)?;
        let start_tree = store.get_tree(&start_commit.tree)?;
        let first_blob = start_tree
            .entries()
            .iter()
            .find(|e| e.name == self.path)
            .ok_or_else(|| VctrlError::NotFound(format!("path '{}' not found", self.path)))?;
        let mut prev_blob_hash = first_blob.hash;
        let mut last_commit_hash = self.start_commit;
        let mut last_commit_info = (
            start_commit.author.clone(),
            start_commit.message.clone(),
            first_blob.hash,
        );

        while let Some(commit_hash) = current {
            iterations += 1;
            if iterations > MAX_BLAME_ITERATIONS {
                return Err(VctrlError::Other(
                    "blame: too many commits to process".into(),
                ));
            }

            if !visited.insert(commit_hash) {
                break;
            }
            let commit = store.get_commit(&commit_hash)?;
            let tree = store.get_tree(&commit.tree)?;

            let entry = match tree.entries().iter().find(|e| e.name == self.path) {
                Some(e) => e,
                None => {
                    break;
                }
            };

            if entry.hash != prev_blob_hash {
                result.push(BlameEntry {
                    commit_hash,
                    blob_hash: entry.hash,
                    author: commit.author.clone(),
                    message: commit.message.clone(),
                });
                prev_blob_hash = entry.hash;
            }

            last_commit_hash = commit_hash;
            last_commit_info = (commit.author.clone(), commit.message.clone(), entry.hash);

            current = commit.parents.first().copied();
        }

        if result.is_empty() || result.last().map(|e| e.commit_hash) != Some(last_commit_hash) {
            result.push(BlameEntry {
                commit_hash: last_commit_hash,
                blob_hash: last_commit_info.2,
                author: last_commit_info.0,
                message: last_commit_info.1,
            });
        }

        Ok(result)
    }
}