prek 0.4.8

A fast Git hook manager written in Rust, designed as a drop-in alternative to pre-commit, reimagined.
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

use std::io::ErrorKind;
use std::ops::Deref;
use std::path::{Path, PathBuf};

use anyhow::{Context, Result};
use etcetera::BaseStrategy;
use prek_consts::env_vars::{EnvVars, EnvVarsRead};
use serde::Deserialize;

fn user_config_path() -> Option<PathBuf> {
    if let Some(path) = EnvVars.var_os(EnvVars::PREK_INTERNAL__USER_CONFIG_PATH) {
        return Some(PathBuf::from(path));
    }

    etcetera::choose_base_strategy()
        .ok()
        .map(|strategy| strategy.config_dir().join("prek").join("prek.toml"))
}

/// Options loaded from a user-level `prek.toml` file.
#[derive(Debug, Clone)]
pub(crate) struct FilesystemOptions(Options);

impl FilesystemOptions {
    /// Load user-level options from the platform config directory.
    pub(crate) fn user() -> Result<Option<Self>> {
        let Some(path) = user_config_path() else {
            tracing::trace!(
                "Skipping global config lookup because no platform config directory was found"
            );
            return Ok(None);
        };

        tracing::trace!(path = %path.display(), "Searching for global config");
        Self::from_file(&path)
    }

    fn from_file(path: &Path) -> Result<Option<Self>> {
        let content = match fs_err::read_to_string(path) {
            Ok(content) => {
                tracing::debug!(path = %path.display(), "Read global config");
                content
            }
            Err(err)
                if matches!(
                    err.kind(),
                    ErrorKind::NotFound | ErrorKind::NotADirectory | ErrorKind::PermissionDenied
                ) =>
            {
                tracing::trace!(
                    path = %path.display(),
                    "Global config not found or inaccessible, skipping"
                );
                return Ok(None);
            }
            Err(err) => {
                return Err(err)
                    .with_context(|| format!("Failed to read global config `{}`", path.display()));
            }
        };

        toml::from_str(&content)
            .map(Self)
            .map(Some)
            .with_context(|| format!("Failed to parse global config `{}`", path.display()))
    }
}

impl Deref for FilesystemOptions {
    type Target = Options;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

/// Options as represented in the global `prek.toml` file.
#[derive(Debug, Clone, Default, Deserialize)]
#[serde(default, rename_all = "snake_case")]
pub(crate) struct Options {
    #[serde(alias = "auto_update")]
    update: Option<UpdateOptions>,
}

/// Options for the `update` command.
#[derive(Debug, Clone, Default, Deserialize)]
#[serde(default, rename_all = "snake_case")]
struct UpdateOptions {
    cooldown_days: Option<u8>,
}

/// Resolved settings for the `update` command.
#[derive(Debug, Clone, Copy)]
pub(crate) struct UpdateSettings {
    pub(crate) cooldown_days: u8,
}

impl UpdateSettings {
    pub(crate) fn resolve(
        cli_cooldown_days: Option<u8>,
        filesystem: Option<&FilesystemOptions>,
        project_cooldown_days: Option<u8>,
    ) -> Self {
        Self {
            cooldown_days: cli_cooldown_days
                .or(project_cooldown_days)
                .or_else(|| {
                    filesystem
                        .and_then(|fs| fs.update.as_ref())
                        .and_then(|options| options.cooldown_days)
                })
                .unwrap_or_default(),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::Options;

    #[test]
    fn options_deserializes_update_settings() {
        let options: Options = toml::from_str(
            r"
            [update]
            cooldown_days = 7
            ",
        )
        .unwrap();

        assert_eq!(
            options.update.and_then(|options| options.cooldown_days),
            Some(7)
        );
    }

    #[test]
    fn options_deserializes_legacy_update_key_alias() {
        let options: Options = toml::from_str(
            r"
            [auto_update]
            cooldown_days = 7
            ",
        )
        .unwrap();

        assert_eq!(
            options.update.and_then(|options| options.cooldown_days),
            Some(7)
        );
    }
}