markupwright 0.1.3

Template-driven workspace documentation generator
Documentation
use std::path::{Path, PathBuf};

use super::atomic;

#[derive(Debug, thiserror::Error)]
#[error("failed to {action} generated artifact {}: {source}", path.display())]
pub(crate) struct Error {
    action: &'static str,
    path: PathBuf,
    #[source]
    source: std::io::Error,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum Status {
    Current,
    Missing,
    Changed,
}

#[derive(Clone, Copy, Debug)]
pub(crate) struct GeneratedTextFile<'a> {
    path: &'a Path,
    contents: &'a str,
}

impl<'a> GeneratedTextFile<'a> {
    #[must_use]
    pub(crate) const fn new(path: &'a Path, contents: &'a str) -> Self {
        Self { path, contents }
    }

    pub(crate) fn status(&self) -> Result<Status, Error> {
        match std::fs::symlink_metadata(self.path) {
            Ok(metadata) if metadata.file_type().is_symlink() => {
                return Err(Error {
                    action: "inspect",
                    path: self.path.to_path_buf(),
                    source: std::io::Error::new(
                        std::io::ErrorKind::InvalidInput,
                        "generated output must not be a symbolic link",
                    ),
                });
            }

            Ok(_) => {}

            Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
                return Ok(Status::Missing);
            }

            Err(source) => {
                return Err(Error {
                    action: "inspect",
                    path: self.path.to_path_buf(),
                    source,
                });
            }
        }

        match std::fs::read_to_string(self.path) {
            Ok(existing) if existing == self.contents => Ok(Status::Current),

            Ok(_) => Ok(Status::Changed),

            Err(source) => Err(Error {
                action: "read",
                path: self.path.to_path_buf(),
                source,
            }),
        }
    }

    pub(crate) fn persist(&self) -> Result<(), Error> {
        if let Some(parent) = self
            .path
            .parent()
            .filter(|path| !path.as_os_str().is_empty())
        {
            std::fs::create_dir_all(parent).map_err(|source| Error {
                action: "persist",
                path: self.path.to_path_buf(),
                source,
            })?;
        }

        atomic::replace(self.path, self.contents).map_err(|source| Error {
            action: "persist",
            path: self.path.to_path_buf(),
            source,
        })
    }
}