ephemeris_files/

formatting.rs

//! Run formatters declared by the evaluated repository state.

use std::collections::BTreeMap;
use std::process::{Command, ExitStatus};
use std::{env, fs, io};

use crate::error::IoResultExt as _;
use crate::path::RepositoryPath;
use crate::state::FormatterSpec;
use crate::{FilesError, PathError};

/// A formatter could not be applied to a file.
#[derive(Debug, thiserror::Error)]
pub enum FormatterError {
    /// A partial document declares a per-file formatter override.
    #[error("per-file formatter overrides are not allowed for partial documents at `{path}`")]
    PartialOverride {
        /// The partial document that declared the override.
        path: RepositoryPath,
    },
    /// A formatter spec has no command to run.
    #[error("empty formatter command for `{path}`")]
    EmptyCommand {
        /// The file the empty formatter was declared for.
        path: RepositoryPath,
    },
    /// A formatter's declared project root file is missing from its inputs.
    #[error("formatter project root file `{project_root_file}` is unavailable for `{path}`")]
    MissingInput {
        /// The file being formatted.
        path: RepositoryPath,
        /// The missing project root file.
        project_root_file: RepositoryPath,
    },
    /// A formatter command could not be started.
    #[error("could not run formatter `{command}` for `{path}`")]
    Spawn {
        /// The file that was being formatted.
        path: RepositoryPath,
        /// The formatter command that failed to start.
        command: String,
        /// The underlying spawn failure.
        #[source]
        source: io::Error,
    },
    /// A formatter command exited unsuccessfully.
    #[error("formatter `{command}` failed for `{path}` with status {status}: {stderr}")]
    Failed {
        /// The file that was being formatted.
        path: RepositoryPath,
        /// The formatter command that failed.
        command: String,
        /// The formatter process's exit status.
        status: ExitStatus,
        /// The formatter process's captured standard error.
        stderr: String,
    },
}

/// Format a complete candidate in an isolated temporary project.
pub(crate) fn format(
    path: &RepositoryPath,
    candidate: &[u8],
    formatter: &FormatterSpec,
    assembled_inputs: &BTreeMap<RepositoryPath, Vec<u8>>,
) -> Result<Vec<u8>, FilesError> {
    if formatter.command.is_empty() {
        return Err(FormatterError::EmptyCommand { path: path.clone() }.into());
    }
    let temporary = tempfile::tempdir().at_path(env::temp_dir())?;
    let root = temporary.path();
    for (input, content) in assembled_inputs {
        let destination = root.join(input.as_path());
        let Some(parent) = destination.parent() else {
            return Err(PathError::Outside(destination).into());
        };
        fs::create_dir_all(parent).at_path(parent)?;
        fs::write(&destination, content).at_path(&destination)?;
    }
    let project_root = root.join(formatter.project_root_file.as_path());
    if !project_root.is_file() {
        return Err(FormatterError::MissingInput {
            path: path.clone(),
            project_root_file: formatter.project_root_file.clone(),
        }
        .into());
    }
    let target = root.join(path.as_path());
    if let Some(parent) = target.parent() {
        fs::create_dir_all(parent).at_path(parent)?;
    }
    fs::write(&target, candidate).at_path(&target)?;
    let mut command = Command::new(&formatter.command);
    command.args(&formatter.args).arg(path.as_path());
    let output = command
        .current_dir(root)
        .output()
        .map_err(|source| FormatterError::Spawn {
            path: path.clone(),
            command: formatter.command.clone(),
            source,
        })?;
    if !output.status.success() {
        return Err(FormatterError::Failed {
            path: path.clone(),
            command: formatter.command.clone(),
            status: output.status,
            stderr: String::from_utf8_lossy(&output.stderr).trim().to_owned(),
        }
        .into());
    }
    fs::read(&target).at_path(&target)
}

#[cfg(test)]
mod tests {
    use std::collections::BTreeMap;

    use super::format;
    use crate::path::RepositoryPath;
    use crate::state::FormatterSpec;
    use crate::{FilesError, FormatterError};

    #[test]
    fn formats_candidate_with_planner_assembled_inputs() {
        let spec = facet_json::from_str::<FormatterSpec>(
            r#"{"command":"sh","args":["-c","grep -q desired formatter.conf && printf 'bar\\n' > \"$1\"","formatter"],"inputs":["formatter.conf"],"project_root_file":"formatter.conf"}"#,
        )
        .unwrap();
        let inputs = [(
            RepositoryPath::try_from("formatter.conf").unwrap(),
            b"desired\n".to_vec(),
        )]
        .into();
        let output = format(
            &RepositoryPath::try_from("nested/file.txt").unwrap(),
            b"foo\n",
            &spec,
            &inputs,
        )
        .expect("formatter succeeds");
        assert_eq!(output, b"bar\n");
    }

    #[test]
    fn formatter_failure_is_an_error() {
        let spec = facet_json::from_str::<FormatterSpec>(
            r#"{"command":"sh","args":["-c","exit 7","formatter"],"inputs":[],"project_root_file":"file.txt"}"#,
        )
        .unwrap();
        let path = RepositoryPath::try_from("file.txt").unwrap();
        let inputs = [(path.clone(), b"root\n".to_vec())].into();
        assert!(matches!(
            format(&path, b"content", &spec, &inputs),
            Err(FilesError::Formatter(FormatterError::Failed { path: failed, command, status, stderr: _ }))
                if failed == path && command == "sh" && status.code() == Some(7)
        ));
    }

    #[test]
    fn an_empty_formatter_command_is_rejected() {
        let spec = facet_json::from_str::<FormatterSpec>(
            r#"{"command":"","args":[],"inputs":[],"project_root_file":"file.txt"}"#,
        )
        .unwrap();
        let path = RepositoryPath::try_from("file.txt").unwrap();
        assert!(matches!(
            format(&path, b"content", &spec, &BTreeMap::new()),
            Err(FilesError::Formatter(FormatterError::EmptyCommand { path: rejected })) if rejected == path
        ));
    }

    #[test]
    fn a_missing_project_root_file_is_rejected() {
        let spec = facet_json::from_str::<FormatterSpec>(
            r#"{"command":"true","args":[],"inputs":[],"project_root_file":"flake.nix"}"#,
        )
        .unwrap();
        let path = RepositoryPath::try_from("file.txt").unwrap();
        assert!(matches!(
            format(&path, b"content", &spec, &BTreeMap::new()),
            Err(FilesError::Formatter(FormatterError::MissingInput { path: rejected, project_root_file }))
                if rejected == path && project_root_file.to_string() == "flake.nix"
        ));
    }
}