acick 0.2.0

Command line tools for programming contests
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
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

use std::fmt;
use std::io::Write as _;

use anyhow::Context as _;
use chrono::{offset::Local, DateTime, SecondsFormat};
use serde::Serialize;
use structopt::StructOpt;

use crate::cmd::{with_actor, Outcome};
use crate::model::{ContestId, LangName, ProblemId, Service};
use crate::service::Act;
use crate::{Config, Console, Error, Result};

#[derive(StructOpt, Debug, Clone, PartialEq, Eq, Hash)]
#[structopt(rename_all = "kebab")]
pub struct SubmitOpt {
    /// Id of the problem to be submitted
    #[structopt(name = "problem")]
    problem_id: ProblemId,
    /// Overrides the language names specified in config file
    #[structopt(long, short)]
    lang_name: Option<Vec<LangName>>,
    /// Opens the submission status in browser
    #[structopt(name = "open", long, short)]
    need_open: bool,
}

impl SubmitOpt {
    pub fn run(&self, conf: &Config, cnsl: &mut Console) -> Result<SubmitOutcome> {
        with_actor(conf.service_id, conf.session(), |actor| {
            self.run_inner(actor, conf, cnsl)
        })
    }

    pub fn run_inner(
        &self,
        actor: &dyn Act,
        conf: &Config,
        cnsl: &mut Console,
    ) -> Result<SubmitOutcome> {
        // confirm
        let message = format!(
            "submit problem {} to {}?",
            &self.problem_id, &conf.contest_id
        );
        if !cnsl.confirm(&message, false)? {
            return Err(Error::msg("Not submitted"));
        }

        // load problem file
        let problem = conf.load_problem(&self.problem_id, cnsl)?;

        // load source
        let source = conf
            .load_source(&self.problem_id, cnsl)
            .context("Could not load source file")?;
        if source.is_empty() {
            return Err(Error::msg("Found empty source file"));
        }

        // submit
        let lang_names = match &self.lang_name {
            Some(lang_names) => lang_names,
            None => conf.service().lang_names(),
        };
        let lang_name = actor.submit(&conf.contest_id, &problem, lang_names, &source, cnsl)?;

        // open submissions in browser if needed
        if self.need_open {
            actor
                .open_submissions_url(&conf.contest_id, cnsl)
                // coerce error
                .unwrap_or_else(|err| writeln!(cnsl, "{}", err).unwrap_or(()));
        }

        Ok(SubmitOutcome {
            service: Service::new(conf.service_id),
            contest_id: conf.contest_id.to_owned(),
            problem_id: self.problem_id.to_owned(),
            problem_name: problem.name().to_owned(),
            submitted_at: Local::now(),
            lang_name: lang_name.to_owned(),
            source_bytes: source.len(),
        })
    }
}

pub type LocalDateTime = DateTime<Local>;

#[derive(Serialize, Debug, Clone, PartialEq, Eq, Hash)]
pub struct SubmitOutcome {
    service: Service,
    contest_id: ContestId,
    problem_id: ProblemId,
    problem_name: String,
    submitted_at: LocalDateTime,
    lang_name: String,
    source_bytes: usize,
}

impl fmt::Display for SubmitOutcome {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "{} {} {} {} (time: {}, lang: {}, code size: {} Bytes)",
            self.service.id(),
            self.contest_id,
            self.problem_id,
            self.problem_name,
            self.submitted_at
                .to_rfc3339_opts(SecondsFormat::Secs, false),
            self.lang_name,
            self.source_bytes
        )
    }
}

impl Outcome for SubmitOutcome {
    fn is_error(&self) -> bool {
        false
    }
}

#[cfg(test)]
mod tests {
    use tempfile::tempdir;

    use super::*;
    use crate::cmd::tests::run_with;

    #[test]
    #[ignore]
    fn run_default() -> anyhow::Result<()> {
        let test_dir = tempdir()?;

        let login_opt = crate::cmd::LoginOpt {};
        run_with(&test_dir, |conf, cnsl| login_opt.run(conf, cnsl))?;

        let fetch_opt = crate::cmd::FetchOpt::default_test();
        run_with(&test_dir, |conf, cnsl| fetch_opt.run(conf, cnsl))?;

        let opt = SubmitOpt {
            problem_id: "c".into(),
            lang_name: None,
            need_open: false,
        };
        run_with(&test_dir, |conf, cnsl| opt.run(conf, cnsl))?;
        Ok(())
    }
}