outpost-core 0.1.3

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
68
69
70
71
72
73
74
75
76
77

use crate::safety;
use crate::{Outpost, OutpostError, OutpostResult, RefName, Reporter, StepKind, UpstreamRef};

pub struct PullOptions;

pub struct PullReport {
    pub source_updated: bool,
    pub outpost_updated: bool,
}

pub fn run(
    outpost: &Outpost,
    _opts: PullOptions,
    reporter: &mut dyn Reporter,
) -> OutpostResult<PullReport> {
    let branch = outpost.current_branch().map_err(|err| match err {
        OutpostError::BranchNotFound { .. } => OutpostError::NoUpstreamTracking {
            branch: "HEAD".to_owned(),
        },
        other => other,
    })?;
    let source = outpost.source_repo()?;
    if !source.branch_exists(&branch)? {
        return Err(OutpostError::BranchNotFound {
            branch: branch.as_str().to_owned(),
            repo: source.work_tree().to_path_buf(),
        });
    }

    reporter.step(
        StepKind::SourceFetch,
        &format!(
            "fast-forwarding source {} branch {} from origin/{}",
            source.work_tree().display(),
            branch.as_str(),
            branch.as_str()
        ),
    );
    let source_branch_ref = format!("refs/heads/{}", branch.as_str());
    let source_before = source
        .git()
        .run_capture(["rev-parse", &source_branch_ref])?;
    source.fast_forward_branch_from_origin(&branch)?;
    let source_after = source
        .git()
        .run_capture(["rev-parse", &source_branch_ref])?;

    let upstream = UpstreamRef {
        remote: outpost.metadata().remote_name.clone(),
        merge_ref: RefName::parse(format!("refs/heads/{}", branch.as_str()))?,
    };
    safety::check_no_divergence(outpost, &branch, &upstream)?;

    reporter.step(
        StepKind::OutpostFetch,
        &format!(
            "fast-forwarding outpost {} branch {} from {}/{}",
            outpost.work_tree().display(),
            branch.as_str(),
            upstream.remote.as_str(),
            branch.as_str()
        ),
    );
    let before = outpost.git().run_capture(["rev-parse", "HEAD"])?;
    outpost.git().run_check([
        "pull",
        "--ff-only",
        upstream.remote.as_str(),
        branch.as_str(),
    ])?;
    let after = outpost.git().run_capture(["rev-parse", "HEAD"])?;

    Ok(PullReport {
        source_updated: source_before != source_after,
        outpost_updated: before != after,
    })
}