jj-cz 1.1.0

Conventional commits for Jujutsu
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

use jj_lib::revset::{RevsetEvaluationError, RevsetParseError, RevsetResolutionError};

use crate::commit::types::{CommitMessageError, DescriptionError, ScopeError};

#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
pub enum Error {
    // Domain errors
    #[error("Invalid scope: {0}")]
    InvalidScope(String),
    #[error("Invalid description: {0}")]
    InvalidDescription(String),
    #[error("Invalid commit message: {0}")]
    InvalidCommitMessage(String),
    // Infrastructure errors
    #[error("Not a Jujutsu repository")]
    NotARepository,
    #[error("Repository operation failed: {context}")]
    JjOperation { context: String },
    #[error("Repository is locked by another process")]
    RepositoryLocked,
    #[error("Could not get current directory")]
    FailedGettingCurrentDir,
    #[error("Could not load Jujutsu configuration: {context}")]
    FailedReadingConfig { context: String },
    // Application errors
    #[error("Operation cancelled by user")]
    Cancelled,
    #[error("Non-interactive terminal detected")]
    NonInteractive,
    #[error("Failed to resolve revision '{revset}': {context}")]
    RevsetResolutionError { revset: String, context: String },
    #[error("Revision set '{revset}' resolves to multiple commits; specify a single revision")]
    MultipleRevisions { revset: String },
    #[error("--new cannot be used with multiple revisions")]
    NewFlagWithMultipleRevisions,
}

impl From<ScopeError> for Error {
    fn from(value: ScopeError) -> Self {
        Self::InvalidScope(value.to_string())
    }
}

impl From<DescriptionError> for Error {
    fn from(value: DescriptionError) -> Self {
        Self::InvalidDescription(value.to_string())
    }
}

impl From<CommitMessageError> for Error {
    fn from(value: CommitMessageError) -> Self {
        Self::InvalidCommitMessage(value.to_string())
    }
}

impl From<std::io::Error> for Error {
    fn from(_: std::io::Error) -> Self {
        Self::FailedGettingCurrentDir
    }
}

impl<T> From<std::sync::PoisonError<T>> for Error {
    fn from(_: std::sync::PoisonError<T>) -> Self {
        Self::JjOperation {
            context: "internal lock poisoned".to_string(),
        }
    }
}

impl Error {
    pub fn from_revset_parse_error(revset: &str, error: RevsetParseError) -> Self {
        Self::RevsetResolutionError {
            revset: revset.to_string(),
            context: error.to_string(),
        }
    }

    pub fn from_revset_resolution_error(revset: &str, error: RevsetResolutionError) -> Self {
        Self::RevsetResolutionError {
            revset: revset.to_string(),
            context: error.to_string(),
        }
    }

    pub fn from_revset_evaluation_error(revset: &str, error: RevsetEvaluationError) -> Self {
        Self::RevsetResolutionError {
            revset: revset.to_string(),
            context: error.to_string(),
        }
    }
}