cargo-mend 0.16.1

Opinionated visibility auditing for Rust crates and workspaces
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

use std::collections::hash_map::DefaultHasher;
use std::fs;
use std::hash::Hash;
use std::hash::Hasher;
use std::path::Path;
use std::path::PathBuf;

use anyhow::Context;
use anyhow::Result;
use serde::Deserialize;
use serde::Serialize;
use serde_json::to_string;
use toml::from_str;

use super::constants::CONFIG_FILE_NAME;
use super::diagnostics_config::DiagnosticsConfig;
use super::global::GlobalConfig;
use super::prelude_pub_mod::PreludePubMod;

#[derive(Debug, Default, Deserialize)]
struct ConfigFile {
    #[serde(default, rename = "visibility")]
    visibility_config:  VisibilityConfig,
    #[serde(default, rename = "diagnostics")]
    diagnostics_config: Option<DiagnosticsConfig>,
}

#[derive(Debug, Default, Clone, Deserialize, Serialize)]
pub(crate) struct VisibilityConfig {
    #[serde(default)]
    pub(crate) allow_pub_mod:   Vec<String>,
    #[serde(default)]
    pub(crate) allow_pub_items: Vec<String>,
    #[serde(default, rename = "allow_prelude_pub_mod")]
    pub(crate) prelude_pub_mod: PreludePubMod,
}

#[derive(Debug)]
pub(crate) struct LoadedConfig {
    pub(crate) visibility_config:  VisibilityConfig,
    pub(crate) diagnostics_config: DiagnosticsConfig,
    pub(crate) root:               PathBuf,
    pub(crate) fingerprint:        String,
}

pub(crate) fn load_config(
    manifest_dir: &Path,
    workspace_root: &Path,
    explicit: Option<&Path>,
    global: &GlobalConfig,
) -> Result<LoadedConfig> {
    let candidates = explicit.map_or_else(
        || {
            let mut result = Vec::new();
            for root in [manifest_dir, workspace_root] {
                result.push(root.join(CONFIG_FILE_NAME));
            }
            result
        },
        |path| vec![path.to_path_buf()],
    );

    for path in candidates {
        if path.exists() {
            let text = fs::read_to_string(&path)
                .with_context(|| format!("failed to read config {}", path.display()))?;
            let config_file: ConfigFile = from_str(&text)
                .with_context(|| format!("failed to parse config {}", path.display()))?;
            let root = path
                .parent()
                .map_or_else(|| manifest_dir.to_path_buf(), Path::to_path_buf)
                .canonicalize()
                .with_context(|| {
                    format!("failed to canonicalize config root for {}", path.display())
                })?;
            let diagnostics_config = config_file.diagnostics_config.map_or_else(
                || global.diagnostics.clone(),
                |project| global.diagnostics.merge_project(&project),
            );
            // The prelude exemption is a global-only switch; stamp it onto the
            // resolved visibility config before fingerprinting so the cache
            // invalidates when the global toggle changes.
            let mut visibility_config = config_file.visibility_config;
            visibility_config.prelude_pub_mod = global.prelude_pub_mod;
            return Ok(LoadedConfig {
                fingerprint: fingerprint_for(&root, &visibility_config)?,
                visibility_config,
                diagnostics_config,
                root,
            });
        }
    }

    let visibility_config = VisibilityConfig {
        prelude_pub_mod: global.prelude_pub_mod,
        ..VisibilityConfig::default()
    };
    Ok(LoadedConfig {
        fingerprint: fingerprint_for(manifest_dir, &visibility_config)?,
        visibility_config,
        diagnostics_config: global.diagnostics.clone(),
        root: manifest_dir.to_path_buf(),
    })
}

fn fingerprint_for(root: &Path, config: &VisibilityConfig) -> Result<String> {
    let mut hasher = DefaultHasher::new();
    root.to_string_lossy().hash(&mut hasher);
    to_string(config)
        .context("failed to serialize mend config for fingerprinting")?
        .hash(&mut hasher);
    Ok(format!("{:016x}", hasher.finish()))
}