Add api/stats/ route and implement pdf parser with poppler-rs.

Author: SamarthPyati

Cargo.lock

@@ -5,7 +5,7 @@ edition = "2021"
 
 [dependencies]
 colored = "3.0.0"
-poppler = "0.6.0"
+poppler-rs = "0.24.1"
 rust-stemmers = "1.2.0"
 serde = { version = "1.0.219" , features = ["derive"] }
 serde_json = "1.0.140"

Cargo.toml

@@ -12,7 +12,7 @@ mod server;
 mod model;
 
 use crate::model::*;
-use poppler::PopplerDocument;
+use poppler::{Document};
 
 /* Parse all the text (Character Events) from the XML File */
 fn parse_xml_file(file_path: &Path) -> Result<String, ()> {
@@ -51,22 +51,32 @@ fn parse_txt_file(file_path: &Path) -> Result<String, ()> {
 
 /* Parse all the text from the PDF File with Poppler */
 fn parse_pdf_files(file_path: &Path) -> Result<String, ()> {
-    let mut content = String::new();
-            
-    let pdf_file = PopplerDocument::new_from_file(file_path, None).map_err(|err| {
-        eprintln!("{}: Failed to open pdf file as {}", "ERROR".red().bold(), err.to_string().red());
+    let mut file_content = Vec::new();
+
+    File::open(file_path)
+        .and_then(|mut file| file.read_to_end(&mut file_content))
+        .map_err(|err| {
+            eprintln!("{}: Failed to get contents of PDF file {path} as {err}", "ERROR".red().bold(), path = file_path.to_string_lossy().bright_blue(), err = err.to_string().red());
+        })?;
+
+
+    let pdf_file = Document::from_data(&file_content, None).map_err(|err| {
+        eprintln!("{}: Failed to make poppler document out of PDF file {path} as {err}", "ERROR".red().bold(), path = file_path.to_string_lossy().bright_blue(), err = err.to_string().red());
     })?;
 
-    if !pdf_file.is_empty() {
-        for (n, page) in pdf_file.pages().enumerate() { 
-            if let Some(text) = page.get_text() {
-                content.push_str(text);
+
+    let mut content = String::new();
+    if pdf_file.n_pages() > 0 {
+        for i in 0..pdf_file.n_pages() { 
+            if let Some(page) = pdf_file.page(i) {
+                if let Some(text) = page.text() {
+                    content.push_str(&text.as_str());
+                }
             } else {
-                eprintln!("{}: Could not get text of page {n} of {file_path}.", "ERROR".red().bold(), file_path = file_path.to_string_lossy().bright_blue())
+                eprintln!("{}: Could not get text of page {i} of {file_path}.", "ERROR".red().bold(), file_path = file_path.to_string_lossy().bright_blue())
             }
         }
     }
-    println!("{}", content.split_at(1000).0);
     Ok(content)
 }
 

src/main.rs

@@ -87,6 +87,36 @@ pub fn serve_api_search(mut request: Request, model: Arc<Mutex<InMemoryModel>>)
     return request.respond(response);
 }
 
+pub fn serve_api_stats(request: Request, model: Arc<Mutex<InMemoryModel>>) -> io::Result<()> {
+    use serde::Serialize;
+    #[derive(Default, Serialize)]
+    struct Stats {
+        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()
+    };
+
+    let json = match serde_json::to_string(&stats) {
+        Ok(json) => json, 
+        Err(err) => {
+            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");
+    
+    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(), 
@@ -108,6 +138,10 @@ pub fn serve_request(request: Request, model: Arc<Mutex<InMemoryModel>>) -> io::
             serve_api_search(request, model)?
         }
 
+        (Method::Get, "/api/stats") => {
+            serve_api_stats(request, model)?
+        }
+
         _ => {
             return serve_404(request);
         }