raz-core 0.2.4

Universal command generator for Rust projects - Core library with stateless file analysis and cursor-aware execution
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

//! Error types for RAZ Core

use std::path::PathBuf;
use thiserror::Error;

/// Main error type for RAZ operations
#[derive(Error, Debug)]
pub enum RazError {
    #[error("IO error: {0}")]
    Io(#[from] std::io::Error),

    #[error("Configuration error: {message}")]
    Config { message: String },

    #[error("Project analysis failed: {message}")]
    Analysis { message: String },

    #[error("Command execution failed: {command}")]
    Execution { command: String },

    #[error("Provider error: {provider}: {message}")]
    Provider { provider: String, message: String },

    #[error("Invalid workspace: {path}")]
    InvalidWorkspace { path: PathBuf },

    #[error("Parsing error: {message}")]
    Parse { message: String },

    #[error("Feature not available: {feature}")]
    FeatureUnavailable { feature: String },

    #[error("Timeout: {operation}")]
    Timeout { operation: String },

    #[error("Internal error: {message}")]
    Internal { message: String },
}

impl RazError {
    pub fn config(message: impl Into<String>) -> Self {
        Self::Config {
            message: message.into(),
        }
    }

    pub fn analysis(message: impl Into<String>) -> Self {
        Self::Analysis {
            message: message.into(),
        }
    }

    pub fn execution(command: impl Into<String>) -> Self {
        Self::Execution {
            command: command.into(),
        }
    }

    pub fn provider(provider: impl Into<String>, message: impl Into<String>) -> Self {
        Self::Provider {
            provider: provider.into(),
            message: message.into(),
        }
    }

    pub fn invalid_workspace(path: impl Into<PathBuf>) -> Self {
        Self::InvalidWorkspace { path: path.into() }
    }

    pub fn parse(message: impl Into<String>) -> Self {
        Self::Parse {
            message: message.into(),
        }
    }

    pub fn feature_unavailable(feature: impl Into<String>) -> Self {
        Self::FeatureUnavailable {
            feature: feature.into(),
        }
    }

    pub fn timeout(operation: impl Into<String>) -> Self {
        Self::Timeout {
            operation: operation.into(),
        }
    }

    pub fn internal(message: impl Into<String>) -> Self {
        Self::Internal {
            message: message.into(),
        }
    }
}

/// Result type alias for RAZ operations
pub type RazResult<T> = Result<T, RazError>;