snowchains 0.7.0

Tools for online programming contests
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 anyhow::{bail, Context as _};
use std::{fs, path::PathBuf};
use structopt::StructOpt;
use strum::VariantNames as _;
use termcolor::WriteColor;

#[derive(StructOpt, Debug)]
pub struct OptInit {
    /// Overwrites the existing config
    #[structopt(short, long)]
    pub force: bool,

    /// Coloring
    #[structopt(
        long,
        possible_values(crate::ColorChoice::VARIANTS),
        default_value("auto")
    )]
    pub color: crate::ColorChoice,

    /// Directory to create a `snowchains.dhall`
    #[structopt(default_value("."))]
    pub directory: PathBuf,
}

pub(crate) fn run(
    opt: OptInit,
    ctx: crate::Context<impl Sized, impl Sized, impl WriteColor>,
) -> anyhow::Result<()> {
    let OptInit {
        force,
        color: _,
        directory,
    } = opt;

    let crate::Context {
        cwd,
        shell: crate::shell::Shell { mut stderr, .. },
    } = ctx;

    let path = cwd
        .join(directory.strip_prefix(".").unwrap_or(&directory))
        .join("snowchains.dhall");

    if !force && path.exists() {
        bail!(
            "`{}` exists. Enable to `--force` to overwrite",
            path.display(),
        );
    }

    fs::write(
        &path,
        include_str!("../../resources/config/default-config.dhall"),
    )
    .with_context(|| format!("Could not write `{}`", path.display()))?;

    writeln!(stderr, "Wrote `{}`", path.display())?;
    stderr.flush()?;

    Ok(())
}

#[cfg(test)]
mod tests {
    use rusty_fork::rusty_fork_test;

    rusty_fork_test! {
        #[test]
        fn resolve_default_config_dhall() {
            run_resolve_default_config_dhall().unwrap();
        }
    }

    fn run_resolve_default_config_dhall() -> anyhow::Result<()> {
        // https://docs.rs/dhall/0.6.0/src/dhall/semantics/resolve/cache.rs.html#15-35

        use std::{env, thread};

        crossbeam_utils::thread::scope(|scope| {
            scope
                .builder()
                .name("with-stack-size".to_owned())
                .stack_size(crate::STACK_SIZE)
                .spawn(|_| {})
                .unwrap()
                .join()
                .unwrap()
        })
        .unwrap();

        thread::Builder::new()
            .name("with-stack-size".to_owned())
            .stack_size(crate::STACK_SIZE)
            .spawn(|| {
                let cache_dir = tempfile::Builder::new()
                    .prefix("snowchains-tests-")
                    .tempdir()?;

                env::set_var("XDG_CACHE_HOME", cache_dir.path());

                dhall::semantics::parse::parse_str(include_str!(
                    "../../resources/config/default-config.dhall",
                ))?
                .resolve()?;

                cache_dir.close()?;
                Ok(())
            })?
            .join()
            .unwrap()
    }
}