lang-evolve-core/src/utils/mod.rs

use log::{info, error};

use std::fs::File;
use std::io::{Read, Result};
use std::path::Path;

/// Type of supported settings format: yaml or json
#[derive(Debug, PartialEq)]
pub enum SettingsType {
    /// Files ending with the `yml` or `yaml` extension
    Yaml,

    /// Files ending with the `json` extension
    Json,

    /// Other file type, used to describe files without an extension or with an
    /// unsupported extension
    Other,
}

/// Read a file’s content into a `String`
///
/// # Example
///
/// ```no_run
/// let path = std::path::Path::new("./some/path/to/my/file.json");
/// let content = lang_evolve_core::settings::utils::read_file(&path).unwrap();
/// ```
pub fn read_file(path: &Path) -> Result<String> {
    let display = path.display();
    let mut file = match File::open(&path) {
        Err(why) => {
            error!("Could not read {}: {}", display, why.to_string());
            return Err(why);
        }
        Ok(file) => file,
    };
    let mut content = String::new();
    match file.read_to_string(&mut content) {
        Err(why) => {
            error!("Could not read {}: {}", display, why.to_string());
            return Err(why);
        }
        Ok(_) => {
            info!("Content of {} read", display);
            Ok(content)
        }
    }
}

/// Write a `String` into a file
///
/// # Example
///
/// ```no_run
/// let content = String::from("This is my content");
/// let path = std::path::Path::new("./path/to/my/file.txt");
/// lang_evolve_core::settings::utils::write_file(&path, &content).unwrap();
/// ```
pub fn write_file<S>(path: &Path, content: &S) -> Result<()>
where
    S: std::string::ToString,
{
    use std::io::prelude::*;
    let mut file = match File::create(&path) {
        Err(e) => {
            error!("Could not open file {}: {}", path.display(), e.to_string());
            return Err(e);
        }
        Ok(file) => file,
    };
    match file.write_all(content.to_string().as_bytes()) {
        Err(e) => {
            error!(
                "Could not write settings to file {}: {}",
                path.display(),
                e.to_string()
            );
            return Err(e);
        }
        Ok(_) => {
            info!("Wrote settings to file {}", path.display());
        }
    };
    info!("Successfuly written {}", path.display());
    Ok(())
}

/// Get the type of file to be opened based on its extension. Currently
/// supported file types are:
/// * JSON - `.json` extension
/// * Yaml - `.yml` or `.yaml` extensions
///
/// # Arguments
///
/// - `path` - Path of the file to be determined
///
/// # Example
///
/// ```
/// let file_json = std::path::Path::new("file.json");
/// assert_eq!(lang_evolve_core::settings::utils::SettingsType::Json,
///            lang_evolve_core::settings::utils::get_file_type(&file_json));
///
/// let file_yaml = std::path::Path::new("file.yaml");
/// assert_eq!(lang_evolve_core::settings::utils::SettingsType::Yaml,
///            lang_evolve_core::settings::utils::get_file_type(&file_yaml));
///
/// let file_yml = std::path::Path::new("file.yml");
/// assert_eq!(lang_evolve_core::settings::utils::SettingsType::Yaml,
///            lang_evolve_core::settings::utils::get_file_type(&file_yml));
/// ```
pub fn get_file_type(path: &Path) -> SettingsType {
    let extension = match path.extension() {
        None => { return  SettingsType::Other; }
        Some(val) => val,
    };
    let extension = extension
        .to_str()
        .expect("Could not get String out of extension")
        .to_lowercase();
    match extension.as_str() {
        "yml" | "yaml" => SettingsType::Yaml,
        "json" => SettingsType::Json,
        _ => SettingsType::Other,
    }
}