Method pre_run_code

src/cache/mod.rs:241–323

run_code data

(
        &self,
        run: Run,
        rfid: i32,
        test_case: Option<String>,
    )

    /// run_code data
    async fn pre_run_code(
        &self,
        run: Run,
        rfid: i32,
        test_case: Option<String>,
    ) -> Result<(HashMap<&'static str, String>, [String; 2]), Error> {
        trace!("pre-run code...");
        use crate::helper::code_path;
        use std::fs::File;
        use std::io::Read;

        let mut p = self.get_problem(rfid)?;
        if p.desc.is_empty() {
            trace!("Problem description does not exist, pull desc and exec again...");
            self.get_question(rfid).await?;
            p = self.get_problem(rfid)?;
        }

        let d: Question = serde_json::from_str(&p.desc)?;
        let conf = &self.0.conf;
        let mut json: HashMap<&'static str, String> = HashMap::new();
        let mut code: String = "".to_string();

        let maybe_file_testcases: Option<String> = test_cases_path(&p)
            .map(|file_name| {
                let mut tests = "".to_string();
                File::open(file_name)
                    .and_then(|mut file_descriptor| file_descriptor.read_to_string(&mut tests))
                    .map(|_| Some(tests))
                    .unwrap_or(None)
            })
            .unwrap_or(None);

        let maybe_all_testcases: Option<String> = if d.all_cases.is_empty() {
            None
        } else {
            Some(d.all_cases.to_string())
        };

        // Takes test cases using following priority
        // 1. cli parameter
        // 2. if test cases file exist, use the file test cases(user can edit it)
        // 3. test cases from problem desc all test cases
        // 4. sample test case from the task
        let test_case = test_case
            .or(maybe_file_testcases)
            .or(maybe_all_testcases)
            .unwrap_or(d.case);

        File::open(code_path(&p, None)?)?.read_to_string(&mut code)?;

        let code = if conf.code.edit_code_marker {
            let begin = code.find(&conf.code.start_marker);
            let end = code.find(&conf.code.end_marker);
            if let (Some(l), Some(r)) = (begin, end) {
                code.get((l + conf.code.start_marker.len())..r)
                    .map(|s| s.to_string())
                    .unwrap_or_else(|| code)