impl iterators

src/main.rs

@@ -10,12 +10,12 @@ fn main() -> Result<(), Box<dyn Error>> {
     // Args returns an iterator of args from cli
     // Collect turns an iterator into a collection
     // In this case transform values of args into a vector
-    let args: Vec<String> = env::args().collect();
+    // let args: Vec<String> = env::args().collect();
     
 
     // let config = Config::build(&args)?;
     // or
-    let config = Config::build(&args).unwrap_or_else(|err| {
+    let config = Config::build(env::args()).unwrap_or_else(|err| {
         eprintln!("Problem parsing arguments: {err}");
         process::exit(1);
     });
@@ -56,15 +56,18 @@ struct Config {
 }
 
 impl Config {
-    fn build(args: &[String]) -> Result<Config, &'static str> {
+    fn build(mut args: impl Iterator<Item = String>) -> Result<Config, &'static str> {
-        if args.len() > 3 {
+        args.next(); // skip first argument because is the name of the program
-            return Err("Too many arguments. Usage: minigrep <query> <file_path>");
+
-        }
+        let query = match args.next() {
-        if args.len() < 3 {
+            Some(arg) => arg,
-            return Err("Too few arguments. Usage: minigrep <query> <file_path>");
+            None => return Err("No query strings")
-        }
+        };
-        let query = args[1].clone();
+
-        let file_path = args[2].clone();
+        let file_path = match args.next() {
+            Some(arg) => arg,
+            None => return Err("No file path")
+        };
 
         let ignore_case = env::var("IGNORE_CASE").is_ok();
 

src/main_std.rs

@@ -0,0 +1,74 @@
+use std::fs;
+use std::env;
+use std::error::Error;
+use std::process;
+
+use minigrep::{search, search_case_insensitive};
+
+
+fn main() -> Result<(), Box<dyn Error>> {
+    // Args returns an iterator of args from cli
+    // Collect turns an iterator into a collection
+    // In this case transform values of args into a vector
+    let args: Vec<String> = env::args().collect();
+    
+
+    // let config = Config::build(&args)?;
+    // or
+    let config = Config::build(&args).unwrap_or_else(|err| {
+        eprintln!("Problem parsing arguments: {err}");
+        process::exit(1);
+    });
+
+    println!("Searching for {}", config.query);
+    println!("In file {}", config.file_path);
+
+    // run(config)?;
+    // or
+    if let Err(e) = run(config) {
+        eprintln!("Application error: {e}");
+        process::exit(1);
+    }
+    
+    Ok(())
+}
+
+fn run (config: Config) -> Result<(), Box<dyn Error>> {
+    let contents: String = fs::read_to_string(config.file_path)?;
+
+    // results can't be used after contents die
+    let results = if config.ignore_case {
+        search_case_insensitive(&config.query, &contents)
+    } else {
+        search(&config.query, &contents)
+    };
+
+    println!("Found!");
+    for line in results { println!("{line}"); }   
+
+    Ok(())
+}
+
+struct Config {
+    pub query: String,
+    pub file_path: String,
+    pub ignore_case: bool,
+}
+
+impl Config {
+    fn build(args: &[String]) -> Result<Config, &'static str> {
+        if args.len() > 3 {
+            return Err("Too many arguments. Usage: minigrep <query> <file_path>");
+        }
+        if args.len() < 3 {
+            return Err("Too few arguments. Usage: minigrep <query> <file_path>");
+        }
+        let query = args[1].clone();
+        let file_path = args[2].clone();
+
+        let ignore_case = env::var("IGNORE_CASE").is_ok();
+
+        Ok(Config { query, file_path, ignore_case })
+    }
+}
+