cargo-crapapp 0.4.2

Cargo subcommand for building CRAP app installers and self-contained app bundles
Documentation
use crate::bundlers::MacosBundlerKind;
use crate::manifest_file::EulaFile;
use crate::platform_manifest::PlatformManifest;
use crate::target_manifest::TargetManifest;
use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize)]
#[serde(deny_unknown_fields)]
pub struct MacosPlatformManifest<Target = TargetManifest> {
    pub platform: String,
    pub targets: Vec<Target>,
    pub bundle: Vec<MacosBundlerKind>,
    pub pkg: MacosPkgConfig,
    pub eulas: Vec<EulaFile>,
    pub display_icon: Option<String>,
    pub app_binary: Option<String>,
    #[serde(skip, default)]
    pub display_icon_source: Option<String>,
}

impl MacosPlatformManifest<TargetManifest> {
    pub fn new(
        targets: Vec<TargetManifest>,
        display_icon: Option<&str>,
        display_icon_source: Option<&str>,
        app_binary: Option<&str>,
        bundle: Vec<MacosBundlerKind>,
        pkg: MacosPkgConfig,
        eulas: Vec<EulaFile>,
    ) -> Self {
        Self {
            platform: "macos".to_owned(),
            targets,
            bundle,
            pkg,
            eulas,
            display_icon: display_icon.map(str::to_owned),
            app_binary: app_binary.map(str::to_owned),
            display_icon_source: display_icon_source.map(str::to_owned),
        }
    }
}

impl PlatformManifest for MacosPlatformManifest<TargetManifest> {
    fn platform(&self) -> &str {
        &self.platform
    }

    fn targets(&self) -> Vec<&str> {
        self.targets
            .iter()
            .map(|target| target.target.as_str())
            .collect()
    }

    fn write_text(&self, output: &mut String) {
        output.push_str(&format!("  {}\n", self.platform()));

        if let Some(display_icon) = &self.display_icon {
            output.push_str(&format!("    display icon: {display_icon}\n"));
        }

        if !self.bundle.is_empty() {
            let bundles = self
                .bundle
                .iter()
                .map(|bundle| bundle.to_string())
                .collect::<Vec<_>>()
                .join(", ");
            output.push_str(&format!("    bundle: {bundles}\n"));
        }

        if let Some(app_binary) = &self.app_binary {
            output.push_str(&format!("    app binary: {app_binary}\n"));
        }

        if let Some(identifier) = &self.pkg.identifier {
            output.push_str(&format!("    pkg identifier: {identifier}\n"));
        }

        if let Some(install_path) = &self.pkg.install_path {
            output.push_str(&format!("    pkg install path: {install_path}\n"));
        }

        if self.pkg.link_bins {
            output.push_str(&format!("    pkg bin dir: {}\n", self.pkg.bin_dir()));
        }

        if !self.eulas.is_empty() {
            output.push_str("    eulas:\n");

            for eula in &self.eulas {
                let required = if eula.required() {
                    "required"
                } else {
                    "optional"
                };
                output.push_str(&format!("      {} ({required})\n", eula.path()));
            }
        }

        for target in &self.targets {
            output.push_str(&format!("    {}\n", target.target));

            for file in &target.files {
                let marker = if file.executable { "x" } else { "-" };
                output.push_str(&format!(
                    "      [{}] {} -> {}\n",
                    marker, file.source, file.destination
                ));
            }
        }
    }
}

#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct MacosPkgConfig {
    pub identifier: Option<String>,
    pub install_path: Option<String>,
    pub bin_dir: Option<String>,
    #[serde(default = "default_link_bins")]
    pub link_bins: bool,
}

impl Default for MacosPkgConfig {
    fn default() -> Self {
        Self {
            identifier: None,
            install_path: None,
            bin_dir: None,
            link_bins: true,
        }
    }
}

impl MacosPkgConfig {
    pub fn bin_dir(&self) -> &str {
        self.bin_dir.as_deref().unwrap_or("/usr/local/bin")
    }
}

fn default_link_bins() -> bool {
    true
}