knave 0.14.22

A Lisp programming language for humans and agents that infers types and ownership and compiles to readable Rust
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

use std::env::{self, VarError};
use std::time::Duration;

use super::exit_status::ExitStatus;
use super::standard_error::StandardError;
use crate::build::EmittedFormatting;

#[derive(Debug, PartialEq)]
pub struct RustfmtTimeLimit {
    limit: Duration,
}

#[derive(Debug, PartialEq)]
pub struct MalformedTimeLimit {
    variable: String,
}

impl RustfmtTimeLimit {
    pub fn from_environment() -> Result<Self, MalformedTimeLimit> {
        let variable = EmittedFormatting::time_limit_variable();
        let value = env::var(&variable);
        Self::parsed(variable, value)
    }

    pub fn formatting(&self) -> EmittedFormatting {
        EmittedFormatting::within(self.limit)
    }

    fn parsed(
        variable: String,
        value: Result<String, VarError>,
    ) -> Result<Self, MalformedTimeLimit> {
        match value {
            Err(VarError::NotPresent) => Ok(Self::within(EmittedFormatting::TIME_LIMIT)),
            value => value
                .ok()
                .and_then(|milliseconds| milliseconds.parse().ok())
                .map(|milliseconds| Self::within(Duration::from_millis(milliseconds)))
                .ok_or(MalformedTimeLimit { variable }),
        }
    }

    fn within(limit: Duration) -> Self {
        Self { limit }
    }
}

impl MalformedTimeLimit {
    pub fn report(&self) -> ExitStatus {
        StandardError::write_line(format_args!(
            "error: `{}` must be a whole number of milliseconds",
            self.variable
        ));
        ExitStatus::UsageError
    }
}

#[cfg(test)]
mod tests {
    use std::env::VarError;
    use std::time::Duration;

    use super::{MalformedTimeLimit, RustfmtTimeLimit};
    use crate::build::EmittedFormatting;
    use crate::cli::exit_status::ExitStatus;

    struct TimeLimitFixture;

    impl TimeLimitFixture {
        const VARIABLE: &str = "FAKE_RUSTFMT_TIME_LIMIT";

        fn parsed(value: Result<&str, VarError>) -> Result<RustfmtTimeLimit, MalformedTimeLimit> {
            RustfmtTimeLimit::parsed(Self::VARIABLE.to_string(), value.map(str::to_string))
        }

        fn malformed() -> MalformedTimeLimit {
            MalformedTimeLimit {
                variable: Self::VARIABLE.to_string(),
            }
        }
    }

    #[test]
    fn falls_back_to_the_default_limit_without_the_variable() {
        let limit = TimeLimitFixture::parsed(Err(VarError::NotPresent));
        assert_eq!(
            limit,
            Ok(RustfmtTimeLimit::within(EmittedFormatting::TIME_LIMIT))
        );
    }

    #[test]
    fn reads_a_whole_number_of_milliseconds() {
        let limit = TimeLimitFixture::parsed(Ok("250"));
        assert_eq!(
            limit,
            Ok(RustfmtTimeLimit::within(Duration::from_millis(250)))
        );
    }

    #[test]
    fn refuses_a_limit_that_is_not_a_whole_number() {
        let limit = TimeLimitFixture::parsed(Ok("soon"));
        assert_eq!(limit, Err(TimeLimitFixture::malformed()));
    }

    #[test]
    fn reports_a_malformed_limit_as_a_usage_error() {
        assert_eq!(
            TimeLimitFixture::malformed().report(),
            ExitStatus::UsageError
        );
    }
}