[rust]minigrep实现

/* main.rs */
use std::env;
use std::process;
use minigrep;

fn main() {
    let args: Vec<String> = env::args().collect();
    let config: minigrep::Config = minigrep::Config::new(&args).unwrap_or_else(
        |err| {
            eprintln!("Problem parsing arguments: {err}");
            process::exit(-1);
        }
    );

    println!("{:#?}", config);

    match minigrep::run(&config){
        Err(e) => {
            eprintln!("Application error: {e}");
            process::exit(-2);
        },
        Ok(v) => {
            /* $Env:IGNORE_CASE=1; cargo run to poem.txt */
            let search_str = minigrep::return_standard_contents(&config.ignore, config.search_str);
            let v = minigrep::return_standard_contents(&config.ignore, v);
            let result = minigrep::search(search_str.as_str(), v.as_str());
            println!("{:#?}", result);    
        }
    };
}

/* lib.rs */
use std::env;
use std::error::Error;
use std::fs::File;
use std::io::Read;

#[derive(Debug, PartialEq)]
pub enum IsIgnored {
    Yes,
    No,
}

#[derive(Debug, PartialEq)]
pub struct Config{
    pub ignore: IsIgnored,
    pub search_str: String,
    pub file_name: String,
}

impl Config {
    pub fn new(args: &[String]) -> Result<Config, &'static str> {
        if args.len() < 3{
            return Err("Less than 3 arguments");
        }
        let search_str = args[1].clone();
        let file_name = args[2].clone();

        let ignore: IsIgnored = env::var("IGNORE_CASE").is_ok().into();
        
        Ok(Config{
            ignore,
            search_str,
            file_name,
        })
    }
}

pub fn run(config: &Config) -> Result<String, Box<dyn Error>> {
    let file_name = &(config.file_name);
    let mut file = File::open(file_name)?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    Ok(contents)
}

pub fn search<'a>(search_str: &str, contents: &'a str) -> Vec<&'a str> {
    let mut result = Vec::new();
    
    for line in contents.lines(){
        if line.contains(search_str){
            result.push(line);
        }
    }
    result
}

pub fn return_standard_contents(mode: &IsIgnored, contents: String) -> String{
    match mode {
        IsIgnored::Yes => {
            contents.to_lowercase()
        },
        IsIgnored::No => {
            contents.to_string()
        },
    }
}

impl From<bool> for IsIgnored{
    fn from(value: bool) -> IsIgnored{
        if value {
            IsIgnored::Yes
        }else{
            IsIgnored::No
        }
    }
}