cargo-mate 1.8.0

Rust development companion that enhances cargo with intelligent workflows, state management, performance optimization, and comprehensive project monitoring.
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

use serde::{Deserialize, Serialize};
use std::fmt;
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct CargoMessage {
    pub reason: String,
    #[serde(flatten)]
    pub data: MessageData,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(untagged)]
pub enum MessageData {
    CompilerMessage(CompilerMessage),
    BuildScriptExecuted(BuildScriptExecuted),
    CompilerArtifact(CompilerArtifact),
    Other(serde_json::Value),
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct CompilerMessage {
    pub message: DiagnosticMessage,
    #[serde(default)]
    pub package_id: String,
    pub target: Option<Target>,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct DiagnosticMessage {
    pub message: String,
    pub code: Option<DiagnosticCode>,
    pub level: String,
    pub spans: Vec<DiagnosticSpan>,
    pub children: Vec<DiagnosticMessage>,
    pub rendered: Option<String>,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct DiagnosticCode {
    pub code: String,
    pub explanation: Option<String>,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct DiagnosticSpan {
    pub file_name: String,
    pub line_start: usize,
    pub line_end: usize,
    pub column_start: usize,
    pub column_end: usize,
    pub text: Vec<SpanText>,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct SpanText {
    pub text: String,
    pub highlight_start: usize,
    pub highlight_end: usize,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct BuildScriptExecuted {
    pub package_id: String,
    pub linked_libs: Vec<String>,
    pub linked_paths: Vec<String>,
    pub cfgs: Vec<String>,
    pub env: Vec<(String, String)>,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct CompilerArtifact {
    pub package_id: String,
    pub target: Target,
    pub profile: ArtifactProfile,
    pub features: Vec<String>,
    pub filenames: Vec<String>,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct Target {
    pub name: String,
    pub kind: Vec<String>,
    pub src_path: String,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct ArtifactProfile {
    pub opt_level: String,
    pub debuginfo: Option<u32>,
    pub test: bool,
}
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct ParsedError {
    pub code: String,
    pub file: String,
    pub line: usize,
    pub message: String,
}
impl fmt::Display for ParsedError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "[{}] {}:{} - {}", self.code, self.file, self.line, self.message)
    }
}
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct ParsedWarning {
    pub code: String,
    pub file: String,
    pub line: usize,
    pub message: String,
}
impl fmt::Display for ParsedWarning {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "[{}] {}:{} - {}", self.code, self.file, self.line, self.message)
    }
}
pub fn parse_cargo_message(line: &str) -> Option<CargoMessage> {
    serde_json::from_str(line).ok()
}
pub fn format_error(msg: &DiagnosticMessage) -> ParsedError {
    let code = msg
        .code
        .as_ref()
        .map(|c| c.code.clone())
        .unwrap_or_else(|| "unknown".to_string());
    let (file, line) = if !msg.spans.is_empty() {
        (msg.spans[0].file_name.clone(), msg.spans[0].line_start)
    } else {
        ("unknown".to_string(), 0)
    };
    ParsedError {
        code,
        file,
        line,
        message: msg.message.clone(),
    }
}
pub fn format_warning(msg: &DiagnosticMessage) -> ParsedWarning {
    let code = msg
        .code
        .as_ref()
        .map(|c| c.code.clone())
        .unwrap_or_else(|| "unknown".to_string());
    let (file, line) = if !msg.spans.is_empty() {
        (msg.spans[0].file_name.clone(), msg.spans[0].line_start)
    } else {
        ("unknown".to_string(), 0)
    };
    ParsedWarning {
        code,
        file,
        line,
        message: msg.message.clone(),
    }
}