balls 0.2.0

Git-native task tracker for parallel agent 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
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

use std::fmt;
use std::io;
use std::path::PathBuf;

#[derive(Debug)]
pub enum BallError {
    Io(io::Error),
    Json(serde_json::Error),
    Git(String),
    TaskNotFound(String),
    InvalidTask(String),
    NotInitialized,
    NotARepo,
    AlreadyClaimed(String),
    DepsUnmet(String),
    NotClaimable(String),
    Cycle(String),
    WorktreeExists(PathBuf),
    Conflict(String),
    Other(String),
}

impl fmt::Display for BallError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            BallError::Io(e) => write!(f, "io error: {}", e),
            BallError::Json(e) => write!(f, "json error: {}", e),
            BallError::Git(s) => write!(f, "git error: {}", s),
            BallError::TaskNotFound(id) => write!(f, "task not found: {}", id),
            BallError::InvalidTask(s) => write!(f, "invalid task: {}", s),
            BallError::NotInitialized => {
                write!(f, "not initialized. Run `bl init`")
            }
            BallError::NotARepo => write!(f, "not a git repository"),
            BallError::AlreadyClaimed(id) => write!(f, "task {} is already claimed", id),
            BallError::DepsUnmet(id) => write!(f, "task {} has unmet dependencies", id),
            BallError::NotClaimable(id) => write!(f, "task {} is not claimable", id),
            BallError::Cycle(s) => write!(f, "dependency cycle: {}", s),
            BallError::WorktreeExists(p) => {
                write!(f, "worktree already exists: {} (try `bl drop`)", p.display())
            }
            BallError::Conflict(s) => write!(f, "conflict: {}", s),
            BallError::Other(s) => write!(f, "{}", s),
        }
    }
}

impl std::error::Error for BallError {}

impl From<io::Error> for BallError {
    fn from(e: io::Error) -> Self {
        BallError::Io(e)
    }
}

impl From<serde_json::Error> for BallError {
    fn from(e: serde_json::Error) -> Self {
        BallError::Json(e)
    }
}

pub type Result<T> = std::result::Result<T, BallError>;

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn display_all_variants() {
        let cases: Vec<BallError> = vec![
            BallError::Io(io::Error::other("boom")),
            BallError::Json(serde_json::from_str::<i32>("x").unwrap_err()),
            BallError::Git("fatal".into()),
            BallError::TaskNotFound("bl-x".into()),
            BallError::InvalidTask("bad".into()),
            BallError::NotInitialized,
            BallError::NotARepo,
            BallError::AlreadyClaimed("bl-x".into()),
            BallError::DepsUnmet("bl-x".into()),
            BallError::NotClaimable("bl-x".into()),
            BallError::Cycle("loop".into()),
            BallError::WorktreeExists(PathBuf::from("/tmp/x")),
            BallError::Conflict("merge".into()),
            BallError::Other("misc".into()),
        ];
        for e in &cases {
            let s = format!("{}", e);
            assert!(!s.is_empty());
        }
    }

    #[test]
    fn from_io_error() {
        let e: BallError = io::Error::other("x").into();
        assert!(matches!(e, BallError::Io(_)));
    }

    #[test]
    fn from_json_error() {
        let e: BallError = serde_json::from_str::<i32>("oops").unwrap_err().into();
        assert!(matches!(e, BallError::Json(_)));
    }

    #[test]
    fn error_is_std_error() {
        let e = BallError::NotARepo;
        let s: &dyn std::error::Error = &e;
        assert!(!s.to_string().is_empty());
    }
}