mlua_pkg/

config.rs

//! Single entry value for the operations in [`crate::ops`].
//!
//! [`Config`] bundles *where things live* ([`Project`]) with *what the
//! manifest says* ([`ManifestSource`]).  Every operation takes a `&Config`,
//! so an embedding application has exactly one type to build, and every
//! knob that `mlua-pkg.toml` / the CLI flags can express is reachable from
//! Rust without touching the filesystem first:
//!
//! | knob | carried by |
//! |------|-----------|
//! | `--mlua-pkgs-dir` / `MLUA_PKG_DIR` | [`PkgDir`](crate::PkgDir) inside [`Project`] |
//! | manifest / lockfile location | [`Project`] |
//! | `[package]` + `[deps.<name>]` (the whole `mlua-pkg.toml`) | [`ManifestSource::Value`] holding a [`Manifest`] |
//! | `add` arguments | [`AddSpec`](crate::ops::AddSpec) |
//! | `update` flags | [`UpdateOpts`](crate::ops::UpdateOpts) |
//!
//! # File vs value
//!
//! [`ManifestSource::File`] is what the CLI uses: the manifest is read from
//! `project.manifest_path()` and, for `add` / `update`, written back there.
//!
//! [`ManifestSource::Value`] is the SDK form: the caller hands over a
//! [`Manifest`] it built (or parsed with [`Manifest::from_toml_str`]).
//! Nothing is written to `manifest_path()`; operations that would change the
//! manifest return the new one in their report instead
//! ([`AddReport::manifest`](crate::ops::AddReport::manifest),
//! [`UpdateReport::manifest`](crate::ops::UpdateReport::manifest)).
//! The lockfile and the cache / vendored directories are still written to
//! the paths in [`Project`] in both modes — they are outputs, not inputs.
//!
//! ```rust,no_run
//! use mlua_pkg::{manifest::{Dep, Manifest, Package}, ops, Config, PkgDir, Project};
//! use std::collections::HashMap;
//!
//! # fn main() -> Result<(), mlua_pkg::PkgError> {
//! let root = "/srv/app";
//! let project = Project::in_dir(root, PkgDir::default_in(root));
//!
//! // Build the manifest in memory instead of writing mlua-pkg.toml.
//! let mut deps = HashMap::new();
//! deps.insert("lshape".to_string(), Dep {
//!     git: "https://github.com/ynishi/lshape".into(),
//!     tag: Some("v0.1".into()),
//!     rev: None, branch: None, entry: None, target_dir: None, patch_dir: None, patch_drift: None,
//! });
//! let manifest = Manifest {
//!     package: Package { name: "app".into(), version: "0.1.0".into(), entry: None },
//!     deps,
//! };
//!
//! let cfg = Config::with_manifest(project, manifest);
//! let report = ops::install(&cfg)?;
//! assert_eq!(report.direct, 1);
//! # Ok(())
//! # }
//! ```

use crate::{manifest::Manifest, PkgError, Project};

/// Where [`ops`](crate::ops) takes the manifest from.
#[derive(Debug, Clone, PartialEq)]
pub enum ManifestSource {
    /// Read `project.manifest_path()`; `add` / `update` write back to it.
    File,
    /// Use this value; nothing is written to `manifest_path()`.
    Value(Manifest),
}

/// Everything an operation needs: paths plus the manifest.
#[derive(Debug, Clone, PartialEq)]
pub struct Config {
    project: Project,
    manifest: ManifestSource,
}

impl Config {
    /// File-backed manifest at `project.manifest_path()` (the CLI's mode).
    pub fn new(project: Project) -> Self {
        Self {
            project,
            manifest: ManifestSource::File,
        }
    }

    /// In-memory manifest; `manifest_path()` is never read or written.
    pub fn with_manifest(project: Project, manifest: Manifest) -> Self {
        Self {
            project,
            manifest: ManifestSource::Value(manifest),
        }
    }

    /// Paths (manifest / lockfile / [`PkgDir`](crate::PkgDir)).
    pub fn project(&self) -> &Project {
        &self.project
    }

    /// How the manifest is supplied.
    pub fn manifest_source(&self) -> &ManifestSource {
        &self.manifest
    }

    /// `true` for [`ManifestSource::Value`].
    pub fn manifest_is_value(&self) -> bool {
        matches!(self.manifest, ManifestSource::Value(_))
    }

    /// The manifest this config resolves to: a parse of `manifest_path()`
    /// for [`ManifestSource::File`], a clone for [`ManifestSource::Value`].
    ///
    /// # Errors
    ///
    /// File mode only: whatever [`Manifest::from_path`] returns.
    pub fn load_manifest(&self) -> Result<Manifest, PkgError> {
        match &self.manifest {
            ManifestSource::File => Manifest::from_path(self.project.manifest_path()),
            ManifestSource::Value(m) => Ok(m.clone()),
        }
    }

    /// Same paths, manifest replaced by `manifest` as a value.
    ///
    /// Used by `update` to re-run `install` against the manifest it just
    /// rewrote without going through the filesystem.
    pub fn replace_manifest(&self, manifest: Manifest) -> Self {
        Self::with_manifest(self.project.clone(), manifest)
    }
}

impl From<Project> for Config {
    fn from(project: Project) -> Self {
        Self::new(project)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::PkgDir;
    use std::collections::HashMap;

    fn manifest() -> Manifest {
        Manifest {
            package: crate::manifest::Package {
                name: "x".into(),
                version: "0.1.0".into(),
                entry: None,
            },
            deps: HashMap::new(),
        }
    }

    #[test]
    fn file_mode_reads_manifest_path() {
        let tmp = tempfile::tempdir().unwrap();
        let project = Project::in_dir(tmp.path(), PkgDir::default_in(tmp.path()));
        std::fs::write(
            project.manifest_path(),
            "[package]\nname = \"f\"\nversion = \"0.1.0\"\n",
        )
        .unwrap();
        let cfg = Config::new(project);
        assert!(!cfg.manifest_is_value());
        assert_eq!(cfg.load_manifest().unwrap().package.name, "f");
    }

    #[test]
    fn value_mode_never_touches_manifest_path() {
        let tmp = tempfile::tempdir().unwrap();
        let project = Project::in_dir(tmp.path(), PkgDir::default_in(tmp.path()));
        let cfg = Config::with_manifest(project, manifest());
        assert!(cfg.manifest_is_value());
        assert_eq!(cfg.load_manifest().unwrap().package.name, "x");
        assert!(!cfg.project().manifest_path().exists());
    }

    #[test]
    fn replace_manifest_keeps_paths() {
        let project = Project::new("m.toml", "m.lock", "pkgs");
        let cfg = Config::new(project.clone());
        let mut m = manifest();
        m.package.name = "y".into();
        let cfg2 = cfg.replace_manifest(m);
        assert_eq!(cfg2.project(), &project);
        assert!(cfg2.manifest_is_value());
        assert_eq!(cfg2.load_manifest().unwrap().package.name, "y");
    }
}