Add Proper Comments to explain structs

SamarthPyati · SamarthPyati · commit 630145f7c1e5 · 2025-07-07T10:04:32.000+05:30
diff --git a/src/main.rs b/src/main.rs
@@ -2,7 +2,8 @@ use std:: {
     env::{self}, 
     fs::{self, File}, 
     io::{self, BufReader, BufWriter, Read}, 
-    path::Path, process::{exit, ExitCode}, 
+    path::Path, 
+    process::{exit, ExitCode}, 
     str::{self}, 
     sync::{Arc, Mutex}, 
     thread
diff --git a/src/model.rs b/src/model.rs
@@ -18,18 +18,15 @@ pub trait Model {
    Map of term with its frequency of occurence single document. */
 pub type FreqTable = HashMap::<String, usize>;  
 
-/* PREVIOUS: Map of a document with a pair containing (frequency table, total terms in that table (i.e sum of values)). */
-// pub type FreqTableIndex = HashMap::<PathBuf, (usize, FreqTable)>;
-
 /* Answers how frequently a term occurs in all documents. 
    Map of term with frequency of occurence in all corpus of documents.*/
 pub type GlobalTermFreq = HashMap::<String, usize>;
 
 #[derive(Serialize, Deserialize)]
 pub struct Doc {
-    count: usize, 
-    ft: FreqTable, 
-    last_modified: SystemTime
+    count: usize,                   // Total number of terms (tokens) present in this document.
+    ft: FreqTable,                  //  Frequency table mapping each term to the number of times it appears within this document
+    last_modified: SystemTime       // The last time this document was modified on disk. Used to detect outdated indexes and trigger reindexing when needed.
 }
 
 pub type Docs = HashMap::<PathBuf, Doc>;
@@ -41,16 +38,15 @@ pub struct InMemoryModel {
 }
 
 fn compute_tf(term: &str, doc: &Doc) -> f32 {
-    let n = doc.ft.get(term).cloned().unwrap_or(0) as f32;   
-    let d = doc.count as f32;
-    n / d
+    let n = doc.ft.get(term).cloned().unwrap_or(0) as f32;    // Number of times term occured in document
+    let d = doc.count as f32;                                          // Total number of terms present in document 
+    n / d   
 }
 
 fn compute_idf(term: &str, model: &InMemoryModel) -> f32 {
-    let n = model.docs.len() as f32;
-    // NOTE: Can lead to division by 0 if term is not in Document Corpus
-    // Set Denominator to 1 if turns to 0
-    let d  = model.gtf.get(term).cloned().unwrap_or(1) as f32;
+    let n = model.docs.len() as f32;                                    // Number of documents in corpus
+    // NOTE: Can lead to division by 0 if term is not in Document Corpus, Set Denominator to 1 if turns to 0
+    let d  = model.gtf.get(term).cloned().unwrap_or(1) as f32;  // Number of times term occured in document corpus
     f32::log10(n / d)
 }
 
diff --git a/src/server.rs b/src/server.rs
@@ -1,113 +1,94 @@
-use std::{
-    self,
-    cmp::Ordering,
-    fs::File,
-    io::{self, ErrorKind},
-    path::Path,
-    process::exit,
-    str,
-    sync::{Arc, Mutex},
-};
 use tiny_http::{Header, Method, Request, Response, Server, StatusCode};
+use std::{
+    self, 
+    cmp::Ordering, 
+    fs::File, 
+    io::{self, ErrorKind}, 
+    path::Path, 
+    process::exit, 
+    str, 
+    sync::{Arc, Mutex}
+}; 
 
-use super::model::*;
 use colored::Colorize;
+use super::model::*;
 
 pub fn serve_404(request: Request) -> io::Result<()> {
     return request.respond(Response::from_string("404").with_status_code(StatusCode(404)));
 }
 
+
 pub fn serve_500(request: Request) -> io::Result<()> {
     return request.respond(Response::from_string("500").with_status_code(StatusCode(500)));
 }
 
+
 pub fn serve_400(request: Request, message: &str) -> io::Result<()> {
-    return request.respond(
-        Response::from_string(format!("400: {message}")).with_status_code(StatusCode(400)),
-    );
+    return request.respond(Response::from_string(format!("400: {message}")).with_status_code(StatusCode(400)));
 }
 
+
 pub fn serve_static_file(request: Request, file_path: &str, content_type: &str) -> io::Result<()> {
     let html_file = match File::open(Path::new(file_path)) {
-        Ok(file) => file,
+        Ok(file) => file, 
         Err(err) => {
-            eprintln!(
-                "{}: Could not open html file {file_path} as {err}",
-                "ERROR".bold().red(),
-                file_path = file_path.bright_blue(),
-                err = err.to_string().red()
-            );
+            eprintln!("{}: Could not open html file {file_path} as {err}", "ERROR".bold().red(), file_path = file_path.bright_blue(), err = err.to_string().red());
             if err.kind() == ErrorKind::NotFound {
                 return serve_404(request);
             }
             return serve_500(request);
         }
     };
-    let header = Header::from_bytes("Content-Type", content_type)
-        .expect("Should be a valid Content-Type while passing the header.");
+    let header = Header::from_bytes("Content-Type", content_type).expect("Should be a valid Content-Type while passing the header.");
     return request.respond(Response::from_file(html_file).with_header(header));
 }
 
-pub fn serve_api_search(mut request: Request, model: Arc<Mutex<InMemoryModel>>) -> io::Result<()> {
+
+pub fn serve_api_search(mut request: Request, model: Arc<Mutex<InMemoryModel>>) -> io::Result<()>{
     let mut buf = Vec::new();
-    // Read the entire body of request
+    // Read the entire body of request 
     if let Err(err) = request.as_reader().read_to_end(&mut buf) {
-        eprintln!(
-            "{}: Could not read body of request as {err}",
-            "ERROR".bold().red(),
-            err = err.to_string().red()
-        );
+        eprintln!("{}: Could not read body of request as {err}", "ERROR".bold().red(), err = err.to_string().red());
         return serve_500(request);
     }
 
     let body = match str::from_utf8(&mut buf) {
-        Ok(body) => body.chars().collect::<Vec<_>>(),
+        Ok(body) => body.chars().collect::<Vec<_>>(), 
         Err(err) => {
-            eprintln!(
-                "{}: Could not interpret body as UTF-8 string as {err}",
-                "ERROR".bold().red(),
-                err = err.to_string().red()
-            );
+            eprintln!("{}: Could not interpret body as UTF-8 string as {err}", "ERROR".bold().red(), err = err.to_string().red());
             return serve_400(request, "Body must be a valid UTF-8 string");
         }
     };
 
-    println!(
-        "Recieved Query: \'{}\'",
-        body.iter().collect::<String>().bright_blue()
-    );
+    println!("Recieved Query: \'{}\'", body.iter().collect::<String>().bright_blue());
 
     let model = model.lock().unwrap();
     let results = match model.search_query(&body) {
-        Ok(results) => results,
-        Err(()) => return serve_500(request),
+        Ok(results) => results, 
+        Err(()) => return serve_500(request)
     };
-
-    let mut content = Vec::new();
+    
+    let mut content= Vec::new();
     // Display document ranks (if rank turns 0 while iterating, stop from there)
     for (path, rank) in results.iter().take(10) {
         if rank.partial_cmp(&0f32) == Some(Ordering::Equal) {
             break;
         }
         println!("      {} => {}", path.display(), rank);
         content.push((path, rank));
-    }
+    } 
 
     let json = match serde_json::to_string(&content) {
-        Ok(json) => json,
+        Ok(json) => json, 
         Err(err) => {
-            eprintln!(
-                "{}: could not convert search results to JSON as {err}",
-                "ERROR".bold().red(),
-                err = err.to_string().red()
-            );
+            eprintln!("{}: could not convert search results to JSON as {err}", "ERROR".bold().red(), err = err.to_string().red());
             return serve_500(request);
         }
     };
 
     let content_header = Header::from_bytes("Content-Type", "application/json")
-        .expect("Header entered is not a garbage value");
-
+                                                    .expect("Header entered is not a garbage value");
+    
     let response = Response::from_string(json).with_header(content_header);
 
     return request.respond(response);
@@ -117,45 +98,41 @@ pub fn serve_api_stats(request: Request, model: Arc<Mutex<InMemoryModel>>) -> io
     use serde::Serialize;
     #[derive(Default, Serialize)]
     struct Stats {
-        doc_count: usize,
-        unique_term_count: usize,
+        doc_count: usize, 
+        unique_term_count: usize, 
     }
 
     let model = model.lock().unwrap();
     let stats = Stats {
-        doc_count: model.docs.len(),
-        unique_term_count: model.gtf.len(),
+        doc_count: model.docs.len(), 
+        unique_term_count: model.gtf.len()
     };
 
     let json = match serde_json::to_string(&stats) {
-        Ok(json) => json,
+        Ok(json) => json, 
         Err(err) => {
-            eprintln!(
-                "{}: could not convert search results to JSON as {err}",
-                "ERROR".bold().red(),
-                err = err.to_string().red()
-            );
+            eprintln!("{}: could not convert search results to JSON as {err}", "ERROR".bold().red(), err = err.to_string().red());
             return serve_500(request);
         }
     };
 
     let content_header = Header::from_bytes("Content-Type", "application/json")
-        .expect("Header entered is not a garbage value");
-
+                                                    .expect("Header entered is not a garbage value");
+    
     let response = Response::from_string(json).with_header(content_header);
 
     return request.respond(response);
 }
 
 pub fn serve_request(request: Request, model: Arc<Mutex<InMemoryModel>>) -> io::Result<()> {
-    println!(
-        "{info}: Received request! method: [{req}], url: {url:?}",
-        info = "INFO".bright_cyan(),
+    println!("{info}: Received request! method: [{req}], url: {url:?}",
+        info = "INFO".bright_cyan(), 
         req = &request.method().as_str().bright_green(),
         url = &request.url()
     );
 
     match (&request.method(), request.url()) {
+        
         (Method::Get, "/") | (Method::Get, "/index.html") => {
             serve_static_file(request, "src/index.html", "text/html; charset=utf-8")?
         }
@@ -164,9 +141,13 @@ pub fn serve_request(request: Request, model: Arc<Mutex<InMemoryModel>>) -> io::
             serve_static_file(request, "src/index.js", "text/javascript; charset=utf-8")?
         }
 
-        (Method::Post, "/api/search") => serve_api_search(request, model)?,
+        (Method::Post, "/api/search") => {
+            serve_api_search(request, model)?
+        }
 
-        (Method::Get, "/api/stats") => serve_api_stats(request, model)?,
+        (Method::Get, "/api/stats") => {
+            serve_api_stats(request, model)?
+        }
 
         _ => {
             return serve_404(request);
@@ -176,37 +157,22 @@ pub fn serve_request(request: Request, model: Arc<Mutex<InMemoryModel>>) -> io::
     Ok(())
 }
 
+
 pub fn start(address: &str, model: Arc<Mutex<InMemoryModel>>) -> Result<(), ()> {
-    let address_str = "http://".to_string() + &address + "/";
-    let server = Server::http(address)
-        .map_err(|err| {
-            eprintln!(
-                "{}: Could not create initiate server at {address} as {err}",
-                "ERROR".bold().red(),
-                address = address.bold().bright_blue(),
-                err = err.to_string().red()
-            );
-            exit(1);
-        })
-        .unwrap();
-
-    println!(
-        "{info}: Server Listening at: {address}",
-        info = "INFO".bright_cyan(),
-        address = address_str.cyan()
-    );
+    let address_str = "http://".to_string() + &address + "/"; 
+    let server = Server::http(address).map_err(|err| {
+        eprintln!("{}: Could not create initiate server at {address} as {err}", "ERROR".bold().red(), address = address.bold().bright_blue(), err = err.to_string().red());
+        exit(1);
+    }).unwrap();
+
+    println!("{info}: Server Listening at: {address}", info = "INFO".bright_cyan(), address = address_str.cyan());
 
     for request in server.incoming_requests() {
-        serve_request(request, Arc::clone(&model))
-            .map_err(|err| {
-                eprintln!(
-                    "{}: Failed to serve the request as {err}",
-                    "ERROR".bold().red(),
-                    err = err.to_string().red()
-                );
-            })
-            .ok(); // <- Don't stop here continue serving requests
+        serve_request(request, Arc::clone(&model)).map_err(|err| {
+            eprintln!("{}: Failed to serve the request as {err}", "ERROR".bold().red(), err = err.to_string().red());
+        }).ok(); // <- Don't stop here continue serving requests
     }
     eprintln!("{}: Server socket has shutdown", "ERROR".bold().red());
     Ok(())
 }
+    
