Reformatted all code

Author: marvin-hansen

Diff for: Readme.md

@@ -9,11 +9,11 @@ Videos: https://www.youtube.com/@rust-academy
 5. [Structs](structs)
 6. [Enums and pattern matching](enums)
 7. [Packages, crates, and modules](modules)
-8. [Common collections](collections) 
+8. [Common collections](collections)
 9. [Error handling](errors)
 10. Generics, Traits, and Lifetimes
     * [Generics](generics)
     * [Traits](traits)
     * [Lifetimes](lifetimes)
-    
+
 11.[Testing](testing) 

Diff for: cli/src/config.rs

@@ -9,7 +9,6 @@ pub struct Config {
 
 impl Config {
     pub fn new(args: &[String]) -> Result<Config, &'static str> {
-
         if args.len() < 3 {
             return Err("not enough arguments. use: -- word file.txt ");
         }
@@ -29,16 +28,15 @@ impl Config {
 
     /// build is a more comprehensive constructor that checks each argument individually
     pub fn build(mut args: impl Iterator<Item=String>) -> Result<Config, &'static str> {
-
         args.next(); // skip first argument
 
         // iterating through each argument allows specific error messages
-        let query = match args.next(){
+        let query = match args.next() {
             None => return Err("Didn't get a query string"),
             Some(arg) => arg,
         };
 
-        let file_path = match args.next(){
+        let file_path = match args.next() {
             None => return Err("Didn't get a file path"),
             Some(arg) => arg,
         };
@@ -54,18 +52,17 @@ impl Config {
             file_path,
             case_sensitive,
         })
-
     }
 }
 
-impl Config{
-    pub fn query(&self) -> String{
+impl Config {
+    pub fn query(&self) -> String {
         self.query.clone()
     }
 
-    pub fn file_path(&self) -> String{
+    pub fn file_path(&self) -> String {
         self.file_path.clone()
-}
+    }
 
     pub fn case_sensitive(&self) -> bool {
         self.case_sensitive

Diff for: cli/src/main.rs

@@ -1,12 +1,13 @@
+use std::{env, process};
+
+use crate::search::search_word_in_file;
+use crate::utils::get_config;
+
 mod simple;
 mod config;
 mod utils;
 mod search;
 
-use std::{env, process};
-use crate::search::search_word_in_file;
-use crate::utils::get_config;
-
 // Requirements
 // 1) Parse two command line argument, the word to search and the file path
 // 2) Read the file from the path into a string
@@ -15,7 +16,7 @@ use crate::utils::get_config;
 fn main() {
     let args: Vec<String> = env::args().collect();
     let config = get_config(args);
-    if let Err(e) = search_word_in_file(config){
+    if let Err(e) = search_word_in_file(config) {
         eprintln!("Application error: {e}"); // redirects output to stdout i.e. terminal
         process::exit(1);
     }

Diff for: cli/src/search.rs

@@ -1,34 +1,33 @@
 use std::error::Error;
 use std::fs;
+
 use crate::config::Config;
 
 pub fn search_word_in_file(config: Config) -> Result<(), Box<dyn Error>> {
-
     let path = config.file_path();
     let pat = &config.query();
     let content = &fs::read_to_string(path)
         .expect("Error opening file");
 
-    let result = if config.case_sensitive(){
+    let result = if config.case_sensitive() {
         search_case_sensitive(pat, content)
-    } else{
+    } else {
         search_case_insensitive(pat, content)
     };
 
     if result.len() > 0 {
-        for line in result{
+        for line in result {
             println!("{}", line);
         }
-
-    } else{
+    } else {
         println!("No results found");
     }
 
     Ok(())
 }
 
 
-fn search_case_sensitive<'a>(pat: &'a str, content: &'a str) -> Vec<&'a str>{
+fn search_case_sensitive<'a>(pat: &'a str, content: &'a str) -> Vec<&'a str> {
     content.lines().filter(|line| line.contains(&pat)).collect()
 }
 
@@ -67,8 +66,5 @@ Trust me.";
             expected,
             search_case_insensitive(query, contents)
         );
-
     }
-
-
 }

Diff for: cli/src/simple.rs

@@ -1,12 +1,10 @@
-
-
 // _simple_word_search contains a number of problems, among others:
 // 1. It does not check if the arguments, query & path actually exist.
 // 2. It does not check if the file can actually be opened and read.
 // 3. It does not check if the search result contains any values.
 use std::fs;
 
-pub fn _simple_word_search(args: Vec<String>){
+pub fn _simple_word_search(args: Vec<String>) {
     // 1) Parse two command line argument, the word to search and the file path
     let word = args[1].to_string();
     let path = args[2].to_string();
@@ -15,7 +13,7 @@ pub fn _simple_word_search(args: Vec<String>){
     let content = &fs::read_to_string(&path).unwrap();
 
     // 3) Search the word in text from the file
-    let result: Vec<&str> = content.lines().filter(| line| line.contains(&word)).collect();
+    let result: Vec<&str> = content.lines().filter(|line| line.contains(&word)).collect();
 
     // 4) Print out each line where the word occurs
     for line in result {

Diff for: cli/src/utils.rs

@@ -6,13 +6,13 @@ pub fn get_config(args: Vec<String>) -> Config {
     let config: Config;
 
     if args.len() > 0 {
-        config = Config::new(&args).unwrap_or_else(|err|{
+        config = Config::new(&args).unwrap_or_else(|err| {
             eprintln!("Problem parsing arguments: {}", err);
             process::exit(1);
         }
         );
-    } else{
-        config = Config::build(env::args()).unwrap_or_else( |err |{
+    } else {
+        config = Config::build(env::args()).unwrap_or_else(|err| {
             eprintln!("Problem parsing arguments: {}", err);
             process::exit(1);
         }
@@ -35,6 +35,5 @@ mod tests {
         assert_eq!(expected.query(), result.query());
         assert_eq!(expected.file_path(), result.file_path());
         assert_eq!(expected.case_sensitive(), result.case_sensitive());
-
     }
 }

Diff for: errors/src/errors.rs

@@ -1,5 +1,5 @@
-use std::fs::File;
 use std::{fs, io};
+use std::fs::File;
 use std::io::Read;
 
 pub fn open_file() {
@@ -12,10 +12,9 @@ pub fn open_file() {
 pub fn result_match_panic(path: &str) {
     let file = File::open("Hello.txt");
     match file {
-        Ok(file) => {},
+        Ok(file) => {}
         Err(e) => panic!("Failed to open {} Error: {}", path, e),
     };
-
 }
 
 /// recoverable_file_open does the following
@@ -31,29 +30,29 @@ pub fn result_match_panic(path: &str) {
 pub fn recoverable_file_open(path: &str) {
     let file = File::open("Hello.txt");
     match file {
-        Ok(file) => {},
+        Ok(file) => {}
         Err(e) =>
-                match e.kind() {
-                    io::ErrorKind::NotFound => {
-                            match File::create(path) {
-                                Ok(file) => (), // return the file
-                                Err(e) =>{
-                                    println!("Error creating file: {}", e);
-                                    return;
-                                }
-                            }
-                    },
-                    other_error => {
-                        panic!("Problem opening the file: {:?}", other_error)
+            match e.kind() {
+                io::ErrorKind::NotFound => {
+                    match File::create(path) {
+                        Ok(file) => (), // return the file
+                        Err(e) => {
+                            println!("Error creating file: {}", e);
+                            return;
+                        }
                     }
-                },
+                }
+                other_error => {
+                    panic!("Problem opening the file: {:?}", other_error)
+                }
+            },
     };
 }
 
 // Type alias for return type
 pub type StringResult = Result<String, io::Error>;
 
-pub fn read_username_from_file(path: &str) -> StringResult{
+pub fn read_username_from_file(path: &str) -> StringResult {
     let file = File::open(path);
 
     let mut f = match file {

Diff for: errors/src/main.rs

@@ -6,12 +6,12 @@ const UNRECOVERABLE: bool = false;
 fn main() {
     if UNRECOVERABLE {
         unrecoverable();
-    } else{
+    } else {
         recoverable();
     }
 }
 
-fn unrecoverable(){
+fn unrecoverable() {
     // test_panic();
     // errors::open_file();
 
@@ -24,7 +24,7 @@ fn test_panic() {
 }
 
 
-fn recoverable(){
+fn recoverable() {
     let path = "Hello.txt";
     errors::recoverable_file_open(path);
 }

Diff for: functional/src/closures.rs

@@ -13,10 +13,10 @@ fn simple_closure() {
 
     let _x = 5;
 
-    let expensive_closure = |num:i32| {
+    let expensive_closure = |num: i32| {
         println!("calculating slowly...");
         thread::sleep(Duration::from_micros(num as u64));
-        num +21
+        num + 21
     };
 
     let forty_two = expensive_closure(21);
@@ -35,11 +35,12 @@ fn closure_syntax() {
     // * Semicolon required ;-)
 
     // Most simple_closure syntax
-    let add_one = |num: i32| num+1;
+    let add_one = |num: i32| num + 1;
     println!("{}", add_one(0));
 
     // Overblown syntax with all clutter
-    fn add_one_v1(x: u32) -> u32 { x + 1 };
+    fn add_one_v1(x: u32) -> u32 { x + 1 }
+    ;
 
     println!("{}", add_one_v1(1));
 
@@ -49,7 +50,7 @@ fn closure_syntax() {
     println!("{}", add_one_v2(2));
 
     // remove all type annotation
-    let add_one_v3 = |x|  { x + 1 };
+    let add_one_v3 = |x| { x + 1 };
     println!("{:?}", add_one_v3(3)); // println falls back to debug b/c of missing type inference
 
     // Removed curly brackets.
@@ -68,14 +69,13 @@ fn closure_syntax() {
 
     let no_arg = || println!("Nothing captured");
     no_arg();
-
 }
 
 fn closure_context_capture() {
     // Closures capture values from their local context in one of three ways:
 
     // 1) borrowing immutably.
-     immutable_borrow_closure();
+    immutable_borrow_closure();
 
     // 2) borrowing mutably.
     mutable_borrow_closure();
@@ -84,7 +84,7 @@ fn closure_context_capture() {
     taking_ownership_closure();
 }
 
-fn  immutable_borrow_closure(){
+fn immutable_borrow_closure() {
     println!("immutable_borrow_closure");
 
     // collection with sample data
@@ -97,7 +97,7 @@ fn  immutable_borrow_closure(){
     println!("After calling closure: {:?}", list);
 }
 
-fn mutable_borrow_closure(){
+fn mutable_borrow_closure() {
     println!("mutable_borrow_closure");
     // mutable collection with sample data
     let mut list = vec![1, 2, 3];
@@ -111,7 +111,7 @@ fn mutable_borrow_closure(){
 }
 
 
-fn taking_ownership_closure(){
+fn taking_ownership_closure() {
     println!("taking_ownership_closure");
 
     // If you want to force the closure to take ownership of the values it uses in the environment
@@ -126,15 +126,14 @@ fn taking_ownership_closure(){
     thread::spawn(move || closure)
         .join()
         .unwrap();
-
 }
 
 
 fn closure_context_value() {
     //  A closure body can do any of the following to the value captured fro its context:
 
     // 1) move a captured value out of the closure,
-     move_captured_value_closure();
+    move_captured_value_closure();
 
     // 2) mutate the captured value,
     mutate_captured_value_closure();
@@ -148,7 +147,8 @@ fn closure_context_value() {
 
 #[derive(Debug)]
 struct Rectangle {
-    width: u32, height: u32,
+    width: u32,
+    height: u32,
 }
 
 fn move_captured_value_closure() {
@@ -162,7 +162,10 @@ fn move_captured_value_closure() {
 
     let mut num_sort_operations = 0;
 
-    list.sort_by_key(|r| {num_sort_operations+=1; r.width});
+    list.sort_by_key(|r| {
+        num_sort_operations += 1;
+        r.width
+    });
 
     println!("{:#?}, sorted in {num_sort_operations} operations", list)
 }