gitcortex-indexer 0.6.3

Incremental AST indexer for GitCortex — tree-sitter parsing, git diff, parallel file indexing
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
129

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

use git2::{Delta, DiffOptions, Repository};
use gitcortex_core::error::{GitCortexError, Result};

// ── Types ─────────────────────────────────────────────────────────────────────

/// What happened to a file between two commits.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum FileChange {
    Added(PathBuf),
    Modified(PathBuf),
    Deleted(PathBuf),
}

impl FileChange {
    pub fn path(&self) -> &Path {
        match self {
            FileChange::Added(p) | FileChange::Modified(p) | FileChange::Deleted(p) => p,
        }
    }
}

// ── Differ ────────────────────────────────────────────────────────────────────

/// Wraps a `git2::Repository` and computes file-level change sets between commits.
pub struct Differ {
    repo: Repository,
}

impl Differ {
    /// Open the repository at `repo_path` (or any parent that is a git repo).
    pub fn open(repo_path: &Path) -> Result<Self> {
        let repo = Repository::discover(repo_path)
            .map_err(|e| GitCortexError::Git(e.message().to_owned()))?;
        Ok(Self { repo })
    }

    /// Hex SHA of the current HEAD commit.
    pub fn head_sha(&self) -> Result<String> {
        let head = self
            .repo
            .head()
            .map_err(|e| GitCortexError::Git(e.message().to_owned()))?;
        let commit = head
            .peel_to_commit()
            .map_err(|e| GitCortexError::Git(e.message().to_owned()))?;
        Ok(commit.id().to_string())
    }

    /// Compute which files changed between `from_sha` (exclusive) and HEAD.
    ///
    /// - `from_sha = None` — diff the empty tree against HEAD (first-time index).
    /// - `from_sha = Some(sha)` — diff that commit against HEAD.
    ///
    /// Only files whose extension is in `supported_exts` are returned.
    pub fn changed_files(
        &self,
        from_sha: Option<&str>,
        supported_exts: &[&str],
    ) -> Result<Vec<FileChange>> {
        let head_tree = self
            .repo
            .head()
            .and_then(|h| h.peel_to_commit())
            .and_then(|c| c.tree())
            .map_err(|e| GitCortexError::Git(e.message().to_owned()))?;

        let from_tree = match from_sha {
            None => None,
            Some(sha) => {
                let oid = git2::Oid::from_str(sha)
                    .map_err(|e| GitCortexError::Git(e.message().to_owned()))?;
                let commit = self
                    .repo
                    .find_commit(oid)
                    .map_err(|e| GitCortexError::Git(e.message().to_owned()))?;
                let tree = commit
                    .tree()
                    .map_err(|e| GitCortexError::Git(e.message().to_owned()))?;
                Some(tree)
            }
        };

        let mut opts = DiffOptions::new();
        opts.ignore_whitespace(false);

        let diff = self
            .repo
            .diff_tree_to_tree(from_tree.as_ref(), Some(&head_tree), Some(&mut opts))
            .map_err(|e| GitCortexError::Git(e.message().to_owned()))?;

        let mut changes: Vec<FileChange> = Vec::new();

        diff.foreach(
            &mut |delta, _progress| {
                let change = match delta.status() {
                    Delta::Added | Delta::Copied | Delta::Renamed => delta
                        .new_file()
                        .path()
                        .map(|p| FileChange::Added(p.to_owned())),
                    Delta::Modified => delta
                        .new_file()
                        .path()
                        .map(|p| FileChange::Modified(p.to_owned())),
                    Delta::Deleted => delta
                        .old_file()
                        .path()
                        .map(|p| FileChange::Deleted(p.to_owned())),
                    _ => None,
                };

                if let Some(c) = change {
                    let ext = c.path().extension().and_then(|e| e.to_str());
                    if ext.map(|e| supported_exts.contains(&e)).unwrap_or(false) {
                        changes.push(c);
                    }
                }
                true
            },
            None,
            None,
            None,
        )
        .map_err(|e| GitCortexError::Git(e.message().to_owned()))?;

        Ok(changes)
    }
}