stanhope/

read_csv.rs

//! *Interpret a well-formatted CSV file into a set of initialized Process structs, one for each row*
//! 
//! When identifying the need for new processes, a well-formatted list can be constructed, with a specified first set of columns, then all remaining columns assumed to be additional flags for templates:
//! 
//! | "Document Number" | "Title" | "Subject" | "Product" | "Author" | "Reviewer" | *TFlag* | *TFlag* | ... |
//! | --- | --- | --- | --- | --- | --- | :---: | :---: | :---: |
//! | ... | ... | ... | ... | ... | ... | x |   | ... |
//! | ... | ... | ... | ... | ... | ... |   | x | ... |
//! | ... | ... | ... | ... | ... | ... |   |   | ... |
//! | ... | ... | ... | ... | ... | ... | x | x | ... |
//! 
//! The ***TFlag*** columns are user-defined. For example, if a ***TFlag*** column is "WarpSpeed" then this module assumes there is a Cascading Stylesheet file called "WarpSpeed.css" available to these processes, and any process with an "x" in the "WarpSpeed" column will have this Template (CSS file) applied.
//! 
//! All other columns are strictly enforced as shown above. Empty values in the data rows are OK, but in the first row of the CSV file, the first 6 columns *must* be those six, in that order.
use crate::read_ebml::Process;

use std::{
	fs::{OpenOptions, File},
	io::{self, BufRead, BufReader, Write},
	path::Path,
};

/// Create CSS files for every TFlag found that doesn't already have a CSS file in the "./assets" directory
pub fn new_css_file_if_none_exists(tflag:&str) {
	let assets_folder = "./assets";
	let new_css_file = assets_folder.to_owned()+"/"+tflag;
	// println!("New CSS file: {}",new_css_file);
	if Path::new(&assets_folder).exists() {
		match Path::new(&new_css_file).exists() {
	        true => (),
	        false => { let mut f = OpenOptions::new()
			            .read(true)
			            .write(true)
			            .create(true)
			            .open(&new_css_file)
			            .expect("Could not open the file!");
			            let mut new_line =  "/* *******************************".to_string();
			            new_line.push_str(&("\n   ".to_owned()+tflag));
			            new_line.push_str("\n   ******************************* */");
	    				f.write(new_line.as_bytes()).expect("Could not write template line into new file!");
			        },
	    };
	}
}

/// Pull header and content data from a specifically-formatted CSV file, and return a list of requested processes (one per CSV data row).
pub fn read_csv(file_name:&String,verbose:bool) -> Vec<Process> {

	// TODO: better handling with blank call (no CSV file?) perhaps with an error thrown
	let read_file = if file_name==&String::from("") { "./DocumentList.csv" } else { file_name };

	// Get all lines from the input file into a vector of Strings
	fn lines_from_file(filename: impl AsRef<Path>) -> io::Result<Vec<String>> {
		BufReader::new(File::open(filename)?).lines().collect()
	}

	// Call to the function above to get all lines from the input file
	let lines = lines_from_file(read_file).expect("Could not load lines");

	// Initialize the output vector as empty, as well as the header row information
	let mut process_rows:Vec<Process> = vec![];
	let mut header_row:Vec<&str> = vec![];

	// Loop through every line in the file
	for (ii,line) in lines.iter().enumerate() {

		// For a single line, a new vector holds each element in the CSV row
		let all_parts: Vec<&str> = line.split(',').collect();
		
		// For the first row:
		if ii==0 {

			// Confirm the first six columns in the header are the right six columns
			// Not case-sensitive in theory, so only compare strings biased in one direction (upper) to reduce false positive rejections
			assert!(all_parts[0].to_string().to_uppercase()=="Document Number".to_string().to_uppercase());
			assert!(all_parts[1].to_string().to_uppercase()=="Title".to_string().to_uppercase());
			assert!(all_parts[2].to_string().to_uppercase()=="Subject".to_string().to_uppercase());
			assert!(all_parts[3].to_string().to_uppercase()=="Product".to_string().to_uppercase());
			assert!(all_parts[4].to_string().to_uppercase()=="Author".to_string().to_uppercase());
			assert!(all_parts[5].to_string().to_uppercase()=="Reviewer".to_string().to_uppercase());

			// Store ALL columns into header_row, not just the first six that were confirmed above
			header_row = all_parts;

		// For every row, so long as it's not a row that's just an empty string
		} else if !(all_parts[0]=="") {

			// Initialize a single process for this single row
			let mut needed_proc = Process::new();

			// Use functions of Process to fill the fields with the info in the first six columns
			needed_proc.set_number(all_parts[0]);
			needed_proc.set_title(all_parts[1]);
			needed_proc.set_subject(all_parts[2]);
			needed_proc.set_product(all_parts[3]);
			needed_proc.set_author(all_parts[4]);
			needed_proc.set_reviewer(all_parts[5]);

			// If there are MORE than the minimum required number of columns, then they are Template columns (TFlag)
			if all_parts.len() > 6 {

				// Loop through all remaining columns
				for jj in 6..all_parts.len() {

					// Look for the case-insensitive value of "x"
					match all_parts[jj] {
						"x"|"X" => {
							// If the column header is "Template" then the CSS file is "Template.css"
							let template_name = header_row[jj].to_string() + ".css";
							if verbose { println!("Template identified: {}",&template_name); }
							// Use function of Process to add another template to the list
							needed_proc.add_template(&template_name);
							new_css_file_if_none_exists(&template_name);
						},
						// don't do anything for a column that doesn't include "x" or "X"
						_ => (),
					}
					
				}
			}

			// Add this process to the list of processes going into the output
			process_rows.push(needed_proc);
		}

	}

	// Return the list of every process found in the file
	process_rows

}

//  ▄▄▄▄▄▄▄▄▄▄▄  ▄▄▄▄▄▄▄▄▄▄▄  ▄▄▄▄▄▄▄▄▄▄▄  ▄▄▄▄▄▄▄▄▄▄▄ 
// ▐░░░░░░░░░░░▌▐░░░░░░░░░░░▌▐░░░░░░░░░░░▌▐░░░░░░░░░░░▌
//  ▀▀▀▀█░█▀▀▀▀ ▐░█▀▀▀▀▀▀▀▀▀ ▐░█▀▀▀▀▀▀▀▀▀  ▀▀▀▀█░█▀▀▀▀ 
//      ▐░▌     ▐░▌          ▐░▌               ▐░▌     
//      ▐░▌     ▐░█▄▄▄▄▄▄▄▄▄ ▐░█▄▄▄▄▄▄▄▄▄      ▐░▌     
//      ▐░▌     ▐░░░░░░░░░░░▌▐░░░░░░░░░░░▌     ▐░▌     
//      ▐░▌     ▐░█▀▀▀▀▀▀▀▀▀  ▀▀▀▀▀▀▀▀▀█░▌     ▐░▌     
//      ▐░▌     ▐░▌                    ▐░▌     ▐░▌     
//      ▐░▌     ▐░█▄▄▄▄▄▄▄▄▄  ▄▄▄▄▄▄▄▄▄█░▌     ▐░▌     
//      ▐░▌     ▐░░░░░░░░░░░▌▐░░░░░░░░░░░▌     ▐░▌     
//       ▀       ▀▀▀▀▀▀▀▀▀▀▀  ▀▀▀▀▀▀▀▀▀▀▀       ▀  

#[cfg(test)]
mod tests {
    // Note this useful idiom: importing names from outer (for mod tests) scope.
	use super::*;
	use std::fs;
	use std::fs::OpenOptions;
	use std::io::Write;

	fn create_test_file(filename:&str, lines:Vec<String>) {
		let mut new_file = OpenOptions::new()
		            .read(true)
		            .write(true)
		            .create(true)
		            .open(filename)
		            .expect("Could not open the file!");
        for line in lines {
        	new_file.write({line+"\n"}.as_bytes()).expect("Could not write line to test-only file!");
        }
	}

	fn destroy_test_file(filename:&str) {
		let _ = fs::remove_file(filename);
	}

	fn generate_minimum_csv_file() -> Vec<String> {
		vec!["Document Number,Title,Subject,Product,Author,Reviewer".to_string()]
	}

	fn generate_csv_with_1000_templates() -> Vec<String> {
		let mut new_vec_of_strings = generate_minimum_csv_file();
		new_vec_of_strings.push(new_vec_of_strings[0].clone());
		//println!("{:?}",new_vec_of_strings);
		for ii in 0..1000 {
			new_vec_of_strings[0].push_str(",Template");
			new_vec_of_strings[0].push_str(&ii.to_string());
			new_vec_of_strings[1].push_str(",x");
		}
		//println!("{:?}",new_vec_of_strings);
		new_vec_of_strings
	}

	fn generate_csv_with_1000_processes() -> Vec<String> {
		let mut new_vec_of_strings = generate_minimum_csv_file();
		//println!("{:?}",new_vec_of_strings);
		for _ii in 0..1000 {
			new_vec_of_strings.push(new_vec_of_strings[0].clone());
		}
		//println!("{:?}",new_vec_of_strings);
		new_vec_of_strings
	}

	fn generate_csv_with_25_templates_250_processes() -> Vec<String> {
		let mut new_vec_of_strings = generate_minimum_csv_file();
		new_vec_of_strings.push(new_vec_of_strings[0].clone());
		//println!("{:?}",new_vec_of_strings);
		for ii in 0..25 {
			new_vec_of_strings[0].push_str(",Template");
			new_vec_of_strings[0].push_str(&ii.to_string());
			new_vec_of_strings[1].push_str(",x");
		}
		for _ii in 1..250 {
			new_vec_of_strings.push(new_vec_of_strings[1].clone());
		}
		//println!("{:?}",new_vec_of_strings);
		new_vec_of_strings
	}

	fn generate_csv_with_allcaps_headers() -> Vec<String> {
		let mut new_vec_of_strings = generate_minimum_csv_file();
		new_vec_of_strings[0] = new_vec_of_strings[0].to_uppercase();
		new_vec_of_strings
	}

	fn generate_csv_with_lowercase_headers() -> Vec<String> {
		let mut new_vec_of_strings = generate_minimum_csv_file();
		new_vec_of_strings[0] = new_vec_of_strings[0].to_lowercase();
		new_vec_of_strings
	}

	fn generate_csv_with_1000_templates_uppercase_x() -> Vec<String> {
		let mut new_vec_of_strings = generate_minimum_csv_file();
		new_vec_of_strings.push(new_vec_of_strings[0].clone());
		//println!("{:?}",new_vec_of_strings);
		for ii in 0..1000 {
			new_vec_of_strings[0].push_str(",Template");
			new_vec_of_strings[0].push_str(&ii.to_string());
			new_vec_of_strings[1].push_str(",X");
		}
		//println!("{:?}",new_vec_of_strings);
		new_vec_of_strings
	}

	// Test different kinds of CSV files

	#[test]
	fn test_minimum() {
		let file_name = "test_minimum.csv".to_string();
		create_test_file(&file_name,generate_minimum_csv_file());

		let list_of_processes = read_csv(&file_name,true);
		assert_eq!(list_of_processes.len(),0);

		destroy_test_file(&file_name);
	}

	#[test]
	fn test_1000_templates_quiet() {
		let file_name = "test_1000_templates.csv".to_string();
		create_test_file(&file_name,generate_csv_with_1000_templates());

		let list_of_processes = read_csv(&file_name,false);
		assert_eq!(list_of_processes.len(),1);
		assert_eq!(list_of_processes[0].get_all_templates().len(),1000);

		destroy_test_file(&file_name);
	}

	#[test]
	fn test_1000_processes_quiet() {
		let file_name = "test_1000_processes.csv".to_string();
		create_test_file(&file_name,generate_csv_with_1000_processes());

		let list_of_processes = read_csv(&file_name,false);
		assert_eq!(list_of_processes.len(),1000);
		assert_eq!(list_of_processes[0].get_all_templates().len(),0);

		destroy_test_file(&file_name);
	}

	#[test]
	fn test_25_templates_250_processes_quiet() {
		let file_name = "test_25_templates_250_processes.csv".to_string();
		create_test_file(&file_name,generate_csv_with_25_templates_250_processes());

		let list_of_processes = read_csv(&file_name,false);
		assert_eq!(list_of_processes.len(),250);
		for ii in 0..250 {
			assert_eq!(list_of_processes[ii].get_all_templates().len(),25);
		}
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_allcaps_csv() {
		let file_name = "test_allcaps.csv".to_string();
		create_test_file(&file_name,generate_csv_with_allcaps_headers());

		let list_of_processes = read_csv(&file_name,true);
		assert_eq!(list_of_processes.len(),0);

		destroy_test_file(&file_name);
	}

	#[test]
	fn test_lowercase_csv() {
		let file_name = "test_lowercase.csv".to_string();
		create_test_file(&file_name,generate_csv_with_lowercase_headers());

		let list_of_processes = read_csv(&file_name,true);
		assert_eq!(list_of_processes.len(),0);

		destroy_test_file(&file_name);
	}

	#[test]
	fn test_uppercase_x_quiet() {
		let file_name = "test_1000_templates_uppercase_x.csv".to_string();
		create_test_file(&file_name,generate_csv_with_1000_templates_uppercase_x());

		let list_of_processes = read_csv(&file_name,false);
		assert_eq!(list_of_processes.len(),1);
		assert_eq!(list_of_processes[0].get_all_templates().len(),1000);

		destroy_test_file(&file_name);
	}


}