greprs_test_5 0.1.3

use std::fs::File;
use std::io::prelude::*;
use std::error::Error;
use std::env;


pub fn run(config: Config) -> Result<(), Box<Error>> {
    let mut f = File::open(config.filename)?; //.expect("file not found");

    let mut contents = String::new(); 
    f.read_to_string(&mut contents)?; //.expect("something went wrong reading the file");
    
    for line in search(&config.query, &contents) {
         println!("{}", line); 
    }
    
    let results = if config.case_sensitive {
         search(&config.query, &contents)
    } else {
         search_case_insensitive(&config.query, &contents)
    };

    for line in results {
         println!("{}", line);
    }

    Ok(())
}
pub struct Config { 
    pub query: String, 
    pub filename: String,
    pub case_sensitive: bool,
 
}

impl Config  { 
  pub fn new(mut args: std::env::Args /*&[String]*/) -> Result<Config, &'static str> {
      if args.len() < 3 {
          return Err("No search string && no file name found");
          
      }
/*      let query = args[1].clone();
*/      let query = match args.next() {
          Some(arg) => arg,
          None => return Err("Didn't get a query string"),
        };
    

/*      let filename = args[2].clone();
*/      let filename = match args.next() {
          Some(arg) => arg, 
          None => return Err("Didn't get a file name"),
        };

      let case_sensitive = env::var("CASE_INSENSITIVE") .is_err();

      
      Ok(Config {
/*           query: query,           filename: filename,
*/           query,                  filename,
           case_sensitive: case_sensitive,
        }) 

  }
}

pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> { 
    
    let /*mut*/ results = Vec::new();
/*   for line in contents.lines() {if line.contains(query) {results.push(line);} 
*/   fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> { 
        contents.lines() 
            .filter(|line| line.contains(query)) 
            .collect()
    }

    results
 
} 
fn search_case_insensitive<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
     let query = query.to_lowercase();
     let mut results = Vec::new();

     for line in contents.lines() {
         if line.to_lowercase().contains(&query) {
             results.push(line);
         }
     }

     results
} 


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

    #[test] 
    fn one_result() {
         let query = "duct"; 
         let contents = "\
Rust: 
safe, fast, productive.
Pick three.";
    
         assert_eq!(
              vec!["safe, fast, productive."],
              search(query, contents) 
         );
    }

    fn case_sensitive() { 
         let query = "duct";
         let contents = "\
Rust: 
safe, fast, productive.
Pick three.
Duct tape.";

         assert_eq!(
             vec!["safe, fast, productive."],
             
             search(query, contents)

         );

    }

    fn case_insensitive() { 
         let query = "duct";
         let contents = "\
Rust: 
safe, fast, productive.
Pick three.
Duct tape.";

         assert_eq!(
             vec!["Rust:","Trust me."],
             
             search_case_insensitive(query, contents)

         );

    }
}