bgit 0.4.2

User-friendly Git wrapper for beginners, automating essential tasks like adding, committing, and pushing changes. It includes smart rules to avoid common pitfalls, such as accidentally adding sensitive files or directories and has exclusive support for portable hooks!
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

use super::AtomicEvent;
use crate::{bgit_error::BGitError, config::global::BGitGlobalConfig, rules::Rule};
use git2::{Repository, StashApplyOptions};
use std::path::Path;

#[derive(Debug, Clone)]
pub(crate) enum StashOperation {
    Pop,
}

pub(crate) struct GitStash<'a> {
    name: String,
    pre_check_rules: Vec<Box<dyn Rule + Send + Sync>>,
    operation: Option<StashOperation>,
    stash_index: Option<usize>,
    _global_config: &'a BGitGlobalConfig,
}

impl<'a> GitStash<'a> {
    pub fn pop_stash(_global_config: &'a BGitGlobalConfig, index: Option<usize>) -> Self {
        GitStash {
            name: "git_stash".to_owned(),
            pre_check_rules: vec![],
            operation: Some(StashOperation::Pop),
            stash_index: index,
            _global_config,
        }
    }
}

impl<'a> AtomicEvent<'a> for GitStash<'a> {
    fn new(_global_config: &'a BGitGlobalConfig) -> Self
    where
        Self: Sized,
    {
        GitStash {
            name: "git_stash".to_owned(),
            pre_check_rules: vec![],
            operation: None,
            stash_index: None,
            _global_config,
        }
    }

    fn get_name(&self) -> &str {
        &self.name
    }

    fn get_action_description(&self) -> &str {
        match &self.operation {
            Some(StashOperation::Pop) => "Pop stash and apply changes",
            None => "No stash operation defined",
        }
    }

    fn add_pre_check_rule(&mut self, rule: Box<dyn Rule + Send + Sync>) {
        self.pre_check_rules.push(rule);
    }

    fn get_pre_check_rule(&self) -> &Vec<Box<dyn Rule + Send + Sync>> {
        &self.pre_check_rules
    }

    fn raw_execute(&self) -> Result<bool, Box<BGitError>> {
        let mut repo = Repository::discover(Path::new("."))
            .map_err(|e| self.to_bgit_error(&format!("Failed to open repository: {e}")))?;

        match &self.operation {
            Some(StashOperation::Pop) => self.pop_stash_impl(&mut repo),
            None => Err(self.to_bgit_error("No stash operation defined")),
        }
    }
}

impl<'a> GitStash<'a> {
    fn pop_stash_impl(&self, repo: &mut Repository) -> Result<bool, Box<BGitError>> {
        let index = self.stash_index.unwrap_or(0);

        // Check if stash exists
        self.check_stash_exists(repo, index)?;

        let mut apply_options = StashApplyOptions::default();

        repo.stash_pop(index, Some(&mut apply_options))
            .map_err(|e| {
                self.to_bgit_error(&format!("Failed to pop stash at index {index}: {e}"))
            })?;

        Ok(true)
    }

    fn check_stash_exists(
        &self,
        repo: &mut Repository,
        index: usize,
    ) -> Result<(), Box<BGitError>> {
        let mut stash_exists = false;
        let mut callback = |stash_index: usize, _message: &str, _oid: &git2::Oid| -> bool {
            if stash_index == index {
                stash_exists = true;
                false // Stop iteration
            } else {
                true // Continue
            }
        };

        repo.stash_foreach(&mut callback)
            .map_err(|e| self.to_bgit_error(&format!("Failed to check stash existence: {e}")))?;

        if !stash_exists {
            return Err(self.to_bgit_error(&format!("Stash at index {index} does not exist")));
        }

        Ok(())
    }
}