stanhope/

write_ebml.rs

//! *Write an EBML file using a prototype, and some basic information about a new process*
//! 
//! Assumption: you know some basic information about a Process struct, enough to fill the basic fields:
//! * **Number** - Document Number
//! * **Title** - Document Title
//! * **Subject** - To what the process applies
//! * **Product** - Output of this process
//! * **Author** - Who is to compose this process
//! * **Reviewer** - Prior to publishing, who is to review
//! 
//! *Note: these aren't the only fields in the Process struct; these are the fields that are strictly required in a well-formatted CSV file when **stanhope** is invoked to read in a list of new processes to create.*
//! 
//! An EBML prototype file is required, and should be in the "assets" folder.

use crate::read_ebml;
use crate::read_ebml::Process;
use crate::write_html;

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

/// Apply the Library folder naming convention introduced in stanhope 0.56.0
/// 
/// The naming convention for a process folder within a library is:
/// > Process Library/NUMBER - TITLE/
/// 
/// For reference, this breaks the previous convention (prior to 0.56.0) which was
/// > Process Library/NUMBER/
/// 
/// The reason for this breaking change is the quality-of-life for users who can't memorize everything by document number alone
/// 
/// Note: the "TITLE" string is sanitized to replace illegal characers with underscores ("_"). Some "illegal" characers might be allowed in file systems, but this function takes a conservative approach to string sanitization. For this purpose, illegal characters include /\:*?"<>|#%&+{}
pub fn get_process_folder_name(p:&Process) -> String {
	String::from("./".to_owned() + p.get_number() + " - " + &p.get_title()
		.replace("/","_")
		.replace("\\","_")
		.replace(":","_")
		.replace("*","_")
		.replace("?","_")
		.replace("\"","_")
		.replace("<","_")
		.replace(">","_")
		.replace("|","_")
		.replace("#","_")
		.replace("%","_")
		.replace("&","_")
		.replace("+","_")
		.replace("{","_")
		.replace("}","_")
		)
}

/// Create a new folder with the same name as the Document **Number**, and write a new EBML file to it.
/// 
/// If the folder already exists, write the file in that directory.
/// 
/// If the folder *and* the file already exist, don't do anything! This function is really only to create a fresh EBML file as a starting point.
pub fn write_ebml(p:&Process,verbose:bool) {

	// New convention: PROCESS NUMBER - PROCESS TITLE is the folder name in the library...
	let path = get_process_folder_name(p);

	// Get loud in that stdout
	if verbose { println!("\n{} folder already exists: {}", &path, Path::new(&path).exists()); }

	/* CRITICAL BREAKING UPDATE!!
	// Assumption: every process has its own folder, and that folder is named the PROCESS NUMBER
	// 
	// That folder also contains the EBML file (that's where we'll put it)
	// let path = "./".to_string() + &p.get_number();
	*/

	// Assumption: EBML file names are the same as the folder name, e.g. "NUMBER - TITLE.ebml"
	let path_to_file = path.to_string() + "/" + &path + ".ebml";

	// Scream out to stdout whether or not the file and/or path already exist
	if verbose {
		println!("{} file already exists: {}", &path_to_file, Path::new(&path_to_file).exists());
		println!("Path to the new file will be: {}",path_to_file);
	}

	// If the EBML file doesn't already exist in the folder
	if !Path::new(&path_to_file).exists() {

		// Check to see if the folder exists, and create it if it doesn't
		match Path::new(&path).exists() {
			true => (),
			false => { let _ = fs::create_dir(&path); },
		};

		// Open the file to write
		let mut file = OpenOptions::new()
		            .read(true)
		            .write(true)
		            .create(true)
		            .open(&path_to_file)
		            .expect("Could not open the file!");

		// Call function that references a template EBML file, and uses Process information to replace variables
	    fill_in_template_ebml_file(&mut file,p);
	    // That function actually does all the writing of the EBML file

	    // The HTML file will be in the same folder with the same name, with .html as the extension
	    let path_to_html_file = path.to_string() + "/" + &path + ".html";
	    // We just wrote an EBML file, so we'll use the built-in function to read it back as a Process object
	    let read_it_back_now = read_ebml::read_ebml(&path_to_file);
	    // Use built-in functions to write HTML from the Process we extracted from the EBML we generated
	    write_html::generate_complete_html(&path_to_html_file,&read_it_back_now);

	    // Windows users: copy a specific batch script into each process folder (presume that it exists in .\assets folder).
	    if cfg!(target_os = "windows") { let _did_copy_work = fs::copy("./assets/EasyButton.bat",path.to_string() + "/EasyButton.bat"); }
	    // Mac users: copy a specific command script into each process folder (presume that it exists in .\assets folder). 
	    if cfg!(target_os = "macos") { let _did_copy_work = fs::copy("./assets/EasyButton.command",path.to_string() + "/EasyButton.command"); }
	    // Linux users: copy a specific shell script into each process folder (presume that it exists in .\assets folder). 
	    if cfg!(target_os = "linux") { let _did_copy_work = fs::copy("./assets/EasyButton.sh",path.to_string() + "/EasyButton.sh"); }

	// If the file already exists, this function doesn't do anything
	} else { if verbose { println!("File already exists!"); print!("\n"); } };

}

/// Write a new EBML file that is line-for-line identical to a reference prototype file, except replace the file's variables with information from the Process struct.
/// 
/// Variables in the prototype follow this pattern: $VARIABLE, where VARIABLE represents the Process.variable field, accessed with Process.get_variable() << "variable" is not an actual field... used as syntactical example...
fn fill_in_template_ebml_file(f:&mut File,p:&Process) {

	// Assume the template file exists in the Assets folder
	let template_file = "./assets/EBML-prototype.ebml";

	// Read every line from the template file into a Vec<String>
	fn lines_from_file(filename: impl AsRef<Path>) -> io::Result<Vec<String>> {
		BufReader::new(File::open(filename)?).lines().collect()
	}

	// Call the function above
	let lines = lines_from_file(template_file).expect("Could not load lines");
	// Use built-in functions to pull out the information out of the process passed into this function
	let number = p.get_number();
	let title = p.get_title();
	let subject = p.get_subject();
	let product = p.get_product();
	let author = p.get_author();
	let reviewer = p.get_reviewer();

	// Special case: Templates. This is the one piece of information in the Process structure that isn't as simple as find-and-replace.
	//
	// However, we will collapse the complexity into a simple find-and-replace by making the "replace" part very convoluted.
	// 
	// If there aren't any templates, then we'll comment out the Template line (clever!)
	// If there are templates, then make lines like this: "Template|Template.css"
	let all_templates = p.get_all_templates();
	let mut template = if !(all_templates.len()==0) {
		"Template|".to_string() + &all_templates[0]
	} else {
		"//Template|Example.css".to_string()
	};
	// That's enough if the number of Templates is 1, but for more than 1 we will add more lines with line breaks prior
	// 
	// All of this happens in the same string. When it is written out ONCE in the same find/replace as simpler variables, the line breaks will become good EBML formatting
	if all_templates.len()>1 {
		for ii in 1..all_templates.len() {
			template = template + "\nTemplate|" + &all_templates[ii];
		}
	}

	// For every line we read from the EBML template, write that **same** line out to the new file
	// In so doing, pass the line to write through each of the find/replace filters, including the convoluted "Template" one
	for line in lines {
		let mut new_line = line;
		new_line = new_line.replace("$NUMBER",number);
		new_line = new_line.replace("$TITLE",title);
		new_line = new_line.replace("$SUBJECT",subject);
		new_line = new_line.replace("$PRODUCT",product);
		new_line = new_line.replace("$AUTHOR",author);
		new_line = new_line.replace("$REVIEWER",reviewer);
		new_line = new_line.replace("Template|$TEMPLATE",&template);
		new_line = new_line + "\n";
		f.write(new_line.as_bytes()).expect("Could not write template line into new file!");
	}
	
}