source: gignore/src/template.rs

// IMPORTANT -- LEGAL NOTICE!

//    gignore: a .gitignore manipulation program
//    Copyright (C) 2026  Asher Mullaney \<asher.mullaney@gmail.com\>
//
//    This program is free software: you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation, either version 3 of the License, or
//    (at your option) any later version.
//
//    This program is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License
//    along with this program.  If not, see <https://www.gnu.org/licenses/>.

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

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

use serde::{Deserialize, Serialize};

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()
        )));
    }
    let extension = (*(template.get_source_file()))
        .to_str()
        .expect("FATAL: Could not convert source_file to string!")
        .split_terminator('.')
        .nth(1);

    dbg!(extension);

    if extension != Some("ggnr") {
        eprint!(
            "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}`"))? {
        eprint!("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(())
}