Місія 7: «Мінне Поле»

🥾 Першокурсник (рівень 1 → оцінка «3»)

У minefield/src/main.rs:

#[derive(Debug)]
enum ReadLogError {
    NotFound(String),
    PermissionDenied,
    Corrupted { offset: usize },
}

fn read_log(path: &str) -> Result<String, ReadLogError> {
    let bytes = match std::fs::read(path) {
        Ok(b) => b,
        Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
            return Err(ReadLogError::NotFound(path.to_string()));
        }
        Err(e) if e.kind() == std::io::ErrorKind::PermissionDenied => {
            return Err(ReadLogError::PermissionDenied);
        }
        Err(_) => return Err(ReadLogError::NotFound(path.to_string())),
    };

    match String::from_utf8(bytes) {
        Ok(text) => Ok(text),
        Err(e) => Err(ReadLogError::Corrupted { offset: e.utf8_error().valid_up_to() }),
    }
}

Тести-шаблони (дописуєш тіла перевірок):

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn reads_clean_file_ok() {
        let result = read_log("fixtures/clean_log.txt");
        assert!(result.is_ok());
    }

    #[test]
    fn missing_file_returns_not_found() {
        let result = read_log("fixtures/missing_log.txt");
        assert!(matches!(result, Err(ReadLogError::NotFound(_))));
    }

    #[test]
    fn corrupted_file_returns_corrupted() {
        let result = read_log("fixtures/corrupted_log.bin");
        assert!(matches!(result, Err(ReadLogError::Corrupted { .. })));
    }
}

Ручний match без ? — цілком нормально для рівня 1. Головне: жодного unwrap()/panic!() на шляху очікуваних збоїв.

⚙️ Магістр (рівень 2 → оцінка «4», захист)

Перепиши read_log, використавши ?, зберігши ідентичну поведінку на тих самих трьох фікстурах:

fn classify_io_error(path: &str, e: std::io::Error) -> ReadLogError {
    match e.kind() {
        std::io::ErrorKind::NotFound => ReadLogError::NotFound(path.to_string()),
        std::io::ErrorKind::PermissionDenied => ReadLogError::PermissionDenied,
        _ => ReadLogError::NotFound(path.to_string()),
    }
}

fn read_log(path: &str) -> Result<String, ReadLogError> {
    let bytes = std::fs::read(path).map_err(|e| classify_io_error(path, e))?;
    let text = String::from_utf8(bytes)
        .map_err(|e| ReadLogError::Corrupted { offset: e.utf8_error().valid_up_to() })?;
    Ok(text)
}

Захист: усно поясни, чому в цьому конкретному випадку зручніший .map_err(...)? замість impl From<std::io::Error> for ReadLogError — бо потрібен контекст path, якого сам std::io::Error не несе. Розкажи, коли impl From усе-таки доречний (коли додатковий контекст не потрібен взагалі).

🏆 Легенда Коледжу (рівень 3 → оцінка «5», розширення)

Додай тихе логування інцидентів, що не перериває обробку решти файлів:

fn read_log_logged(path: &str, log_path: &str) -> Result<String, ReadLogError> {
    match read_log(path) {
        Ok(content) => Ok(content),
        Err(err) => {
            use std::io::Write;
            if let Ok(mut f) = std::fs::OpenOptions::new()
                .create(true)
                .append(true)
                .open(log_path)
            {
                let _ = writeln!(f, "{path}: {err:?}");
            }
            Err(err)
        }
    }
}

fn process_all(paths: &[&str], log_path: &str) -> usize {
    let mut ok_count = 0;
    for path in paths {
        if read_log_logged(path, log_path).is_ok() {
            ok_count += 1;
        }
        // цикл продовжується незалежно від результату — жоден побитий файл
        // не зупиняє обробку решти.
    }
    ok_count
}

Перевір власноруч: запусти process_all на списку з кількох файлів поспіль, серед яких і відсутні, і побиті — і переконайся, що incidents.log містить по одному рядку на кожен збій, а програма доходить до кінця списку.