rustyphoenixlecture 1.0.0

/***************************************
	Auteur : Pierre Aubert
	Mail : pierre.aubert@lapp.in2p3.fr
	Licence : CeCILL-C
****************************************/


use std::{collections::HashMap, path::PathBuf};
use glob::glob;

use crate::phighlighter::{
	phighlighter::PHighlighter,
	phighlither_configuration::load_node_highlight,
	planguage::PLanguage,
};

///Manage all PHighlighter to be used in the lecture
pub struct PHighlighterManager{
	///Vector of all PHighlighter to be used in the lecture
	p_vec_highlighter: Vec<PHighlighter>,
	///Map of PHighlighter names to index them and find them quickly by name
	p_map_name: HashMap<String, usize>,
	///Map of PHighlighter exxention to index them and find them quickly by extention
	p_map_extension: HashMap<String, usize>,
	///Map of PHighlighter to index them and find them quickly by their filename (CMakeLists.txt, Dockerfile, etc)
	p_map_filename: HashMap<String, usize>,
}

impl PHighlighterManager {
	///Constructor of the PHighlighterManager
	/// # Parameters
	/// - `vec_config_directory` : vector of directories where to get all configuration of all PHighlighter to be used
	pub fn new(vec_config_directory: &Vec<PathBuf>) -> Self {
		let mut other = PHighlighterManager {
			p_vec_highlighter: vec![],
			p_map_name: Default::default(),
			p_map_extension: Default::default(),
			p_map_filename: Default::default()
		};
		other.load_from_dir(vec_config_directory);
		return other;
	}
	///Load the PHighlighterManager from a configuration file
	/// # Parameters
	/// - `vec_config_directory` : vector of directories where to get all configuration of all PHighlighter to be used
	fn load_from_dir(&mut self, vec_config_directory: &Vec<PathBuf>){
		//Let's iterate on all configuration directories
		for config_directory in vec_config_directory.iter() {
			//Let's get all the toml files in this directory
			let search_pattern = format!("{}/*.toml", config_directory.to_str().unwrap());
			match glob(&search_pattern) {
				Ok(fileiter) => {
					for config_name in fileiter.into_iter() {
						match config_name {
							Ok(working_file) => {
								let highligher: PHighlighter = load_node_highlight(&working_file);
								let language: PLanguage = highligher.get_language().clone();
								let index_highlighter = self.p_vec_highlighter.len();
								self.p_map_name.insert(String::from(working_file.file_stem().unwrap().to_str().unwrap()), index_highlighter);
								for extention in language.get_vec_extention().iter(){
									self.p_map_extension.insert(extention.clone(), index_highlighter);
								}
								for filename in language.get_vec_filename() {
									self.p_map_filename.insert(filename.clone(), index_highlighter);
								}
								self.p_vec_highlighter.push(highligher);
							},
							Err(err) => panic!("PHighlighterManager::load_from_dir : Cannot use file, error '{}'", err)
						}
					}
				},
				Err(_) => panic!("PHighlighterManager::load_from_dir : Pattern '{}' not found for *.toml configuration", search_pattern)
			};
		}
	}
	///Get the vector of all Highlighter names in the PHighlighterManager
	/// # Returns
	/// Vector of all Highlighter names in the PHighlighterManager
	pub fn get_vec_highlighter_name(&self) -> Vec<String> {
		let vec_name: Vec<String> = self.p_map_name.iter().map(|(key,_)| key.clone()).collect::<Vec<_>>();
		return vec_name;
	}
	///Get the highlighter by source file name
	/// # Parameters
	/// - `source_file` : source file to be highlighted
	/// # Returns
	/// Reference of the found PHighlighter or None if there is no highlighter
	pub fn get_highlighter_by_file(&self, source_file: &PathBuf) -> Option<&PHighlighter> {
		//Let's try first by extension
		let source_extension: String = String::from(source_file.extension().unwrap().to_str().unwrap());
		let highlighter = match self.get_highlighter_by_extension(&source_extension) {
			Some(value) => Some(value),
			None => {
				//No highlighter, let's try by the file name (CMakeLists.txt, Dockerfile, etc)
				match source_file.file_name() {
					Some(filename) => match self.get_highlighter_by_filename(&String::from(filename.to_str().unwrap())) {
						Some(filehigh) => Some(filehigh),
						None => None
					},
					None => None
				}
			}
		};
		return highlighter;
	}
	///Get a highligher by name
	/// # Parameters
	/// - `language_name` : name of the highlighter to get
	/// # Returns
	/// Reference of the found PHighlighter or None if there is no highlighter
	pub fn get_highlighter_by_name(&self, language_name: &String) -> Option<&PHighlighter> {
		match self.p_map_name.get(language_name) {
			Some(index) => match self.p_vec_highlighter.get(*index) {
				Some(highlighter) => Some(highlighter),
				None => panic!("PHighlighterManager::get_highlighter_by_name : wrond index of highlighter {}", index)
			},
			None => None
		}
	}
	///Get a highligher by extension
	/// # Parameters
	/// - `language_extension` : extension of the highlighter to get
	/// # Returns
	/// Reference of the found PHighlighter or None if there is no highlighter
	fn get_highlighter_by_extension(&self, language_extension: &String) -> Option<&PHighlighter> {
		match self.p_map_extension.get(language_extension) {
			Some(index) => match self.p_vec_highlighter.get(*index) {
				Some(highlighter) => Some(highlighter),
				None => panic!("PHighlighterManager::get_highlighter_by_extension : wrond index of highlighter {}", index)
			},
			None => None
		}
	}
	///Get a highligher by file name
	/// # Parameters
	/// - `language_filename` : file name of the highlighter to get (CMakeLists.txt, Dockerfile, etc)
	/// # Returns
	/// Reference of the found PHighlighter or None if there is no highlighter
	fn get_highlighter_by_filename(&self, language_filename: &String) -> Option<&PHighlighter> {
		match self.p_map_filename.get(language_filename) {
			Some(index) => match self.p_vec_highlighter.get(*index) {
				Some(highlighter) => Some(highlighter),
				None => panic!("PHighlighterManager::get_highlighter_by_name : wrond index of highlighter {}", index)
			},
			None => None
		}
	}
}