mitts 0.2.1

Rust-first build and package tooling with a shared artifact cache
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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259

/*
 * Mitts Build — Rust-first build and package tooling with shared artifact cache
 * Copyright (c) 2026 Alexander Panasenko
 *
 * Contact: alex@prod.codes
 * Author: https://prod.codes/about/
 * Project: https://github.com/alex09x/mitts
 * SPDX-License-Identifier: MIT OR Apache-2.0
 */

fn deserialize_maybe_bool_or_string<'de, D>(deserializer: D) -> Result<Option<String>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    #[derive(Deserialize)]
    #[serde(untagged)]
    enum Helper {
        Str(String),
        #[allow(dead_code)]
        Bool(bool),
        Inherited {
            #[serde(default)]
            #[allow(dead_code)]
            workspace: bool,
        },
    }

    match Option::<Helper>::deserialize(deserializer)? {
        Some(Helper::Str(s)) => Ok(Some(s)),
        _ => Ok(None),
    }
}

use serde::Deserialize;
use std::collections::HashMap;
use std::path::PathBuf;

#[derive(Debug, Clone, Deserialize, Default)]
pub struct TomlTest {
    pub name: String,
    pub path: Option<String>,
    #[serde(rename = "required-features")]
    pub required_features: Option<Vec<String>>,
    #[serde(default)]
    pub harness: Option<bool>,
    #[serde(default)]
    pub test: Option<bool>,
    #[serde(default)]
    pub doctest: Option<bool>,
}

#[derive(Debug, Clone, Deserialize, Default)]
pub struct TomlTargetSpec {
    #[serde(default)]
    pub dependencies: HashMap<String, TomlDependency>,
    #[serde(default, rename = "build-dependencies", alias = "build_dependencies")]
    pub build_dependencies: HashMap<String, TomlDependency>,
    #[serde(default, rename = "dev-dependencies", alias = "dev_dependencies")]
    pub dev_dependencies: HashMap<String, TomlDependency>,
}

fn deserialize_maybe_inherited_string<'de, D>(deserializer: D) -> Result<Option<String>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    #[derive(Deserialize)]
    #[serde(untagged)]
    enum Helper {
        Str(String),
        Inherited {
            #[serde(default)]
            #[allow(dead_code)]
            workspace: bool,
        },
    }

    match Option::<Helper>::deserialize(deserializer)? {
        Some(Helper::Str(s)) => Ok(Some(s)),
        Some(Helper::Inherited { .. }) => Ok(None),
        None => Ok(None),
    }
}

fn deserialize_maybe_inherited_vec_string<'de, D>(
    deserializer: D,
) -> Result<Option<Vec<String>>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    #[derive(Deserialize)]
    #[serde(untagged)]
    enum Helper {
        List(Vec<String>),
        Inherited {
            #[serde(default)]
            #[allow(dead_code)]
            workspace: bool,
        },
    }

    match Option::<Helper>::deserialize(deserializer)? {
        Some(Helper::List(s)) => Ok(Some(s)),
        Some(Helper::Inherited { .. }) => Ok(None),
        None => Ok(None),
    }
}

#[derive(Debug, Clone, Deserialize, Default)]
pub struct TomlPackage {
    pub name: String,
    #[serde(default, deserialize_with = "deserialize_maybe_inherited_string")]
    pub version: Option<String>,
    #[serde(default, deserialize_with = "deserialize_maybe_inherited_string")]
    pub edition: Option<String>,
    pub build: Option<TomlBuild>,
    pub links: Option<String>,
    #[serde(default)]
    pub autobins: Option<bool>,
    #[serde(default)]
    pub autotests: Option<bool>,
    #[serde(default)]
    pub autoexamples: Option<bool>,
    #[serde(default)]
    pub autobenches: Option<bool>,
    #[serde(default, deserialize_with = "deserialize_maybe_inherited_string")]
    pub description: Option<String>,
    #[serde(default, deserialize_with = "deserialize_maybe_inherited_string")]
    pub homepage: Option<String>,
    #[serde(default, deserialize_with = "deserialize_maybe_inherited_string")]
    pub repository: Option<String>,
    #[serde(default, deserialize_with = "deserialize_maybe_inherited_vec_string")]
    pub authors: Option<Vec<String>>,
    #[serde(default, deserialize_with = "deserialize_maybe_inherited_string")]
    pub license: Option<String>,
    #[serde(default, deserialize_with = "deserialize_maybe_bool_or_string")]
    pub readme: Option<String>,
    #[serde(
        default,
        rename = "rust-version",
        alias = "rust_version",
        deserialize_with = "deserialize_maybe_inherited_string"
    )]
    pub rust_version: Option<String>,
    #[serde(default)]
    pub resolver: Option<String>,
    #[serde(default)]
    pub workspace: Option<String>,
    #[serde(default, rename = "default-run", alias = "default_run")]
    pub default_run: Option<String>,
}

#[derive(Debug, Clone, Deserialize)]
#[serde(untagged)]
pub enum TomlBuild {
    Disabled(bool),
    Path(String),
}

#[derive(Debug, Clone, Deserialize, Default)]
pub struct TomlWorkspace {
    #[serde(default)]
    pub members: Vec<String>,
    #[serde(default, rename = "default-members")]
    pub default_members: Vec<String>,
    #[serde(default)]
    pub exclude: Vec<String>,
    pub package: Option<HashMap<String, toml::Value>>,
    #[serde(default)]
    pub dependencies: HashMap<String, TomlDependency>,
    #[serde(default)]
    pub lints: Option<toml::Value>,
    #[serde(default)]
    pub resolver: Option<String>,
}

#[derive(Debug, Clone, Deserialize, Default)]
pub struct TomlLib {
    pub name: Option<String>,
    pub path: Option<String>,
    #[serde(default, rename = "proc-macro")]
    pub proc_macro: Option<bool>,
    #[serde(default, rename = "crate-type")]
    pub crate_type: Vec<String>,
    #[serde(default)]
    pub harness: Option<bool>,
    #[serde(default)]
    pub test: Option<bool>,
    #[serde(default)]
    pub doctest: Option<bool>,
    #[serde(default)]
    pub doc: Option<bool>,
}

#[derive(Debug, Clone, Deserialize, Default)]
pub struct TomlBin {
    pub name: String,
    pub path: Option<String>,
    #[serde(rename = "required-features")]
    pub required_features: Option<Vec<String>>,
    #[serde(default)]
    pub harness: Option<bool>,
    #[serde(default)]
    pub test: Option<bool>,
    #[serde(default)]
    pub doctest: Option<bool>,
}

#[derive(Debug, Clone, Deserialize)]
#[serde(untagged)]
pub enum TomlDependency {
    Simple(String),
    Detailed(TomlDetailedDep),
}

#[derive(Debug, Clone, Deserialize, Default)]
pub struct TomlDetailedDep {
    pub version: Option<String>,
    pub path: Option<String>,
    pub git: Option<String>,
    pub features: Option<Vec<String>>,
    #[serde(rename = "default-features", alias = "default_features")]
    pub default_features: Option<bool>,
    pub optional: Option<bool>,
    #[serde(rename = "package", alias = "package-name", alias = "package_name")]
    pub package_name: Option<String>,
}

/// Bidirectional mapping between dependency alias and actual package name.
#[derive(Debug, Default, Clone)]
pub struct DependencyAliases {
    pub alias_to_real: HashMap<String, String>,
    pub real_to_aliases: HashMap<String, Vec<(String, Option<String>)>>,
}

/// Role of a discovered test target, distinguishing lib/bin unit tests from integration tests
/// without relying on name heuristics.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum TestRole {
    /// The library compiled as a unit test (<pkg>_unit_test).
    LibUnit,
    /// A binary compiled as a unit test (<bin>_bin_test), carrying the original bin name.
    BinUnit(String),
    /// An integration test ([[test]] or tests/*.rs).
    Integration,
}

/// A discovered compile target within a package.
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct DiscoveredTarget {
    pub name: String,
    pub kind: String, // "lib", "bin", "proc-macro", "test"
    pub src_path: PathBuf,
    pub edition: Option<String>,
    pub crate_types: Vec<String>,
    pub required_features: Option<Vec<String>>,
    pub harness: bool,
    pub test_role: Option<TestRole>,
    pub explicit_only: bool,
}