cargo-compete 0.10.7

A Cargo subcommand for competitive programming.
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

pub mod common;

use ignore::overrides::Override;
use insta::{assert_json_snapshot, assert_snapshot};
use snowchains_core::web::PlatformKind;
use std::io::BufRead;

#[test]
fn atcoder_abc003() -> anyhow::Result<()> {
    let (output, tree) = run(PlatformKind::Atcoder, "abc003", &b""[..])?;
    assert_snapshot!("atcoder_abc003_output", output);
    assert_json_snapshot!("atcoder_abc003_file_tree", tree, { r#".**["Cargo.lock"]"# => ".." });
    Ok(())
}

#[test]
fn atcoder_abc007() -> anyhow::Result<()> {
    let (output, tree) = run(PlatformKind::Atcoder, "abc007", &b""[..])?;
    assert_snapshot!("atcoder_abc007_output", output);
    assert_json_snapshot!("atcoder_abc007_file_tree", tree, { r#".**["Cargo.lock"]"# => ".." });
    Ok(())
}

#[test]
fn atcoder_agc047() -> anyhow::Result<()> {
    let (output, tree) = run(PlatformKind::Atcoder, "agc047", &b""[..])?;
    assert_snapshot!("atcoder_agc047_output", output);
    assert_json_snapshot!("atcoder_agc047_file_tree", tree, { r#".**["Cargo.lock"]"# => ".." });
    Ok(())
}

#[test]
fn atcoder_m_solutions2020() -> anyhow::Result<()> {
    let (output, tree) = run(PlatformKind::Atcoder, "m-solutions2020", &b""[..])?;
    assert_snapshot!("atcoder_m_solutions2020_output", output);
    assert_json_snapshot!("atcoder_m_solutions2020_file_tree", tree, { r#".**["Cargo.lock"]"# => ".." });
    Ok(())
}

#[cfg(feature = "__test_with_credentials")]
#[test]
fn atcoder_practice() -> anyhow::Result<()> {
    let (output, tree) = run(
        PlatformKind::Atcoder,
        "practice",
        common::atcoder_credentials()?,
    )?;
    assert_snapshot!("atcoder_practice_output", output);
    assert_json_snapshot!("atcoder_practice_file_tree", tree, { r#".**["Cargo.lock"]"# => ".." });
    Ok(())
}

// currently broken
//#[test]
//fn yukicoder_contest_100() -> anyhow::Result<()> {
//    let (output, tree) = run(PlatformKind::Yukicoder, "100", &b""[..])?;
//    assert_snapshot!("yukicoder_contest_100_output", output);
//    assert_json_snapshot!("yukicoder_contest_100_file_tree", tree, { r#".**["Cargo.lock"]"# => ".." });
//    Ok(())
//}

fn run(
    platform: PlatformKind,
    contest: &str,
    input: impl BufRead + 'static,
) -> anyhow::Result<(String, serde_json::Value)> {
    common::run(
        |cwd| -> _ {
            std::fs::write(
                cwd.join("compete.toml"),
                format!(
                    r#"test-suite = "{{{{ manifest_dir }}}}/testcases/{{{{ bin_alias | kebabcase }}}}.yml"

[template]
src = '''
fn main() {{
    todo!();
}}
'''

[template.new]
edition = "2021"
dependencies = '''
proconio = "=0.3.6"
'''

[new]
platform = "{}"
path = "./{{{{ package_name }}}}"
"#,
                    platform.to_kebab_case_str(),
                ),
            )?;

            std::fs::create_dir(cwd.join(".cargo"))?;

            std::fs::write(
                cwd.join(".cargo").join("config.toml"),
                r#"[cargo-new]
name = ""
email = ""
"#,
            )?;

            Ok(())
        },
        input,
        &["", "compete", "n", contest],
        |workspace_root, output| {
            output
                .replace(workspace_root.to_str().unwrap(), "{{ cwd }}")
                .replace(['/', '\\'], "{{ slash_or_backslash }}")
        },
        |_| Ok(Override::empty()),
    )
}