source: gignore/src/template.rs@ 5e61643

use std::{
    path::{
        Path,
        PathBuf,
    },
    io::{self, Write},
    fs,
    os::unix::fs::MetadataExt,
    process,
};

use anyhow::{
    Result,
    Error,
    Context
};

use serde::{Serialize, Deserialize};

use super::{
    open_append,
    open_truncate,
};

#[derive(Serialize, Deserialize, Debug)]
pub(crate) struct Template {
    source_file: PathBuf,
    name: String, 
    append: bool,
}

impl Template {
    pub(crate) fn new(source_file: &Path, name: &str, append: bool) -> Self {
        Template {
            source_file: source_file.to_owned(),
            name: String::from(name),
            append,
        }
    }

    fn get_source_file(&self) -> &PathBuf {
        &self.source_file
    }
    fn change_source_file<T: AsRef<Path>>(&mut self, new: T) {
        self.source_file = new.as_ref().to_owned();
    }
    pub(crate) fn get_name(&self) -> &str {
        &self.name
    }
    pub(crate) fn is_append(&self) -> bool {
        self.append
    }
    fn save(&self) -> Result<()> {
        let path = "/usr/lib/gignore/gignore_templates";

        if !fs::exists(path).context("cannot search for `/usr/lib/gignore/gignore_templates`")? {
            return Err(Error::msg("`/usr/lib/gignore/gignore_templates` does not exist"));
        }

        let mut file_handle = open_append(path.as_ref()).context("cannot open `/usr/lib/gignore/gignore_templates`")?;

        let write_string = serde_json::to_string(&self).context("cannot convert template to JSON using `serde_json`")?;

        file_handle.write_all(
            format!("{write_string}\n").as_bytes()
        ).context("cannot write to `/usr/lib/gignore/gignore_templates`")?;

        Ok(())
    }   
}



fn lib_read() -> Result<Vec<Template>> {
    let path = "/usr/lib/gignore/gignore_templates";

    let mut template_vec: Vec<Template> = Vec::new();

    if fs::read_to_string(path).context("cannot read `/usr/lib/gignore/gignore_templates`")?.is_empty() {
        return Ok(template_vec);
    }

    for line in fs::read_to_string(path).context("cannot read `/usr/lib/gignore/gignore_templates`")?.lines() {
        template_vec.push(serde_json::from_str(&line.trim()).context("cannot convert JSON to `template` instance")?);
    }
    Ok(template_vec)
}

pub(crate) fn find_name(name: &str) -> Result<Option<Template>> {
    let template_vec: Vec<Template> = lib_read().context("cannot read template library")?;

    for item in template_vec {
        if item.get_name() == name {
            return Ok(Some(item));
        }
    }
    Ok(None)
}

pub(crate) fn remove(name: &str) -> Result<()> {
    let path = "/usr/lib/gignore/gignore_templates";

    let mut template_vec: Vec<Template> = lib_read().context("cannot read template library")?;

    template_vec.extract_if(.., |item| item.get_name() == name).for_each(drop);

    let template = match find_name(name).context(format!("cannot search for name {name} in /usr/lib/gignore/gignore_templates"))? {
        None => {
            eprintln!("No template exists in `/usr/lib/gignore/gignore_templates` under the name `{name}`.");
            process::exit(0);
        },
        Some(t) => t,
    };

    clear().context("cannot clear template library file")?;

    if template_vec.is_empty() {
        println!("{path} is now empty.");
        fs::write(path, b"").context("cannot write to `/usr/lib/gignore/gignore_templates`")?;
    } else {
        for item in template_vec {
            item.save().context("cannot save template")?;
        }
    }

    fs::remove_file(template.get_source_file()).context(format!("cannot remove `{}`", template.get_source_file().display()))?;
    Ok(())
}

pub(crate) fn add(mut template: Template) -> Result<()> {
    if !fs::exists(template.get_source_file()).context(format!("cannot search for `{}`", template.get_name()))? {
        return Err(Error::msg(format!("The source file specified, `{}`, does not exist.", template.get_source_file().display())));
    }

    if (*(template.get_source_file())).to_str().expect("FATAL: Could not convert source_file to string!").split_terminator('.').nth(2) != Some("ggnr") {
        eprintln!("WARNING: specified source file, `{}`, does not have the file extension for gignore templates (`.ggnr`). Continue anyway? [y/N]", template.get_source_file().display());

        let mut buf = String::new();
        io::stdin()
            .read_line(&mut buf)
            .context("cannot read from stdin")?;

        match &*buf.to_lowercase().trim() {
            "y" => { eprintln!("Continuing..."); },
            _ => {
                eprintln!("User denied operation. Exiting.");
                process::exit(0);
            },
        }
    };

    let new_template_path = format!("/usr/lib/gignore/{}", template.get_source_file().display());

    if fs::exists(&new_template_path).context(format!("cannot search for `{new_template_path}`"))? {
        eprintln!("WARNING: the file `{new_template_path}` already exists. Overwrite it? [y/N]");
        
        let mut buf = String::new();
        io::stdin()
            .read_line(&mut buf)
            .context("cannot read from stdin")?;

        match &*buf.to_lowercase().trim() {
            "y" => {
                eprintln!("Continuing...");

                fs::remove_file(&new_template_path).context(format!("cannot remove {new_template_path}"))?
            },
            _ => {
                eprintln!("User denied operation. Exiting.");
                process::exit(0);
            },
        };
    };

    drop(
        fs::File::create_new(&new_template_path)
        .context(
            format!("cannot create file `{new_template_path}`")
        )?
    );

    let bytes_written = fs::copy(template.get_source_file(), &*new_template_path).context(format!("cannot copy bytes from `{}` to `{new_template_path}`", template.get_source_file().display()))?;
    if !bytes_written == fs::metadata(
        template.get_source_file()
        )
        .context(
            format!("cannot read metadata of `{}`", template.get_source_file().display()))?
        .size()
    {
        eprintln!("WARNING: Not all bytes of `{}` were written to `{new_template_path}`. ", template.get_source_file().display());
    }

    if find_name(template.get_name()).context("cannot search for name in template library")?.is_some() {
        return Err(Error::msg(format!("A template with the name `{}` already exists!", template.get_name())));
    }
    template.change_source_file(new_template_path);

    template.save().context("cannot save template")?;

    Ok(())
}

fn get_template_contents(name: &str) -> Result<String> {
    let template = find_name(name).context("cannot search for name in template library")?;

    Ok(
        fs::read_to_string(match template {
            Some(ref template) => template,
            None => { return Err(Error::msg(format!("No template under name `{name}`"))) },
        }.get_source_file()).context(format!("cannot read {}", template.unwrap().get_source_file().display()))?
    )
}

pub(crate) fn clear() -> Result<()> {
    let path = "/usr/lib/gignore/gignore_templates";

    open_truncate(path.as_ref()).context("cannot open `/usr/lib/gignore/gignore_templates` in `truncate` mode")?
        .write_all(b"").context("cannot write to /usr/lib/gignore/gignore_templates")?;

    Ok(())
}

pub(crate) fn gitignore_write(name: &str) -> Result<()> {
    let template = find_name(name).context("cannot search for name in template library")?;

    if match template {
        Some(template) => template.is_append(),
        None => { return Err(Error::msg(format!("No template under name `{name}`"))) },
    } {
        let mut file_handle = open_append(".gitignore".as_ref()).context("cannot open `.gitignore` in `append` mode")?;

        file_handle.write_all(get_template_contents(name).context("cannot retrieve contents of template")?.as_bytes()).context("cannot write to `.gitignore`")?;

        return Ok(());
    }

    let mut file_handle = open_truncate(".gitignore".as_ref()).context("cannot open `.gitignore` in `truncate` mode")?;

    file_handle.write_all(
        get_template_contents(name).context("cannot retrieve contents of template")?.as_bytes()
    ).context("cannot write to `.gitignore`")?;

    Ok(())
}

pub(crate) fn list(oneline: bool) -> Result<()> {
    if !oneline {
        for item in lib_read().context("cannot read template library")? {
            if item.is_append() {
                println!("{}: {} <append>", item.get_name(), item.get_source_file().display());
            } else {
                println!("{}: {}", item.get_name(), item.get_source_file().display());
            }
        }
        return Ok(());
    }

    println!();
    for item in lib_read().context("cannot read template library")? {
        if item.is_append() {
            print!("{}: {} (append), ", item.get_name(), item.get_source_file().display());
        } else {
            print!("{}: {}, ", item.get_name(), item.get_source_file().display());
        }
    }
    println!();

    Ok(())
}