outpost-core 0.1.0

Core library for Git Outpost, a clone-backed alternative to git worktree workflows.
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

use std::path::PathBuf;

use crate::{AheadBehind, BranchName, OutpostError, OutpostResult, SourceRepo};

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct OutpostSummary {
    pub path: PathBuf,
    pub current_branch: Option<BranchName>,
    pub state: OutpostState,
    pub ahead_behind: Option<AheadBehind>,
    pub locked: bool,
    pub lock_reason: Option<String>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum OutpostState {
    Clean,
    Dirty,
    Missing,
    NotManaged,
}

pub fn run(source: &SourceRepo) -> OutpostResult<Vec<OutpostSummary>> {
    source
        .registry()?
        .entries()
        .iter()
        .map(|entry| summarize_entry(source, entry))
        .collect()
}

fn summarize_entry(
    source: &SourceRepo,
    entry: &crate::RegistryEntry,
) -> OutpostResult<OutpostSummary> {
    let mut summary = OutpostSummary {
        path: entry.path.clone(),
        current_branch: None,
        state: OutpostState::Missing,
        ahead_behind: None,
        locked: entry.locked,
        lock_reason: entry.lock_reason.clone(),
    };

    if !entry.path.exists() {
        return Ok(summary);
    }

    let outpost = match crate::safety::check_path_is_managed_outpost_of(source, &entry.path) {
        Ok(outpost) => outpost,
        Err(OutpostError::RegistryEntryNotManaged(_)) => {
            summary.state = OutpostState::NotManaged;
            return Ok(summary);
        }
        Err(err) => return Err(err),
    };

    summary.current_branch = outpost.current_branch().ok();
    summary.ahead_behind = outpost.ahead_behind_source().ok();
    summary.state = if outpost.is_dirty()? {
        OutpostState::Dirty
    } else {
        OutpostState::Clean
    };

    Ok(summary)
}