cargo-crapapp 0.4.2

Cargo subcommand for building CRAP app installers and self-contained app bundles
Documentation
use crate::bundlers::LinuxBundlerKind;
use crate::manifest_file::{
    AssociatedFile, EulaFile, FileMapping, LinuxTarget, PlatformManifest as SourcePlatformManifest,
    ShortcutMapping,
};
use crate::platform_manifest::PlatformManifest;
use crate::target_manifest::TargetManifest;
use serde::{Deserialize, Serialize};

#[derive(Debug, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
#[serde(bound(
    deserialize = "Target: Deserialize<'de>",
    serialize = "Target: Serialize"
))]
pub struct LinuxPlatformManifest<Target = LinuxTarget> {
    #[serde(default)]
    pub platform: String,
    #[serde(default)]
    pub targets: Vec<Target>,
    #[serde(
        default,
        deserialize_with = "crate::manifest_file::deserialize_linux_bundles"
    )]
    pub bundle: Vec<LinuxBundlerKind>,
    pub install_path: Option<String>,
    pub bin_dir: Option<String>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub files: Vec<FileMapping>,
    #[serde(default)]
    pub associated_files: Vec<AssociatedFile>,
    #[serde(default)]
    pub eulas: Vec<EulaFile>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub shortcuts: Vec<ShortcutMapping>,
    pub display_icon: Option<String>,
}

impl<Target> LinuxPlatformManifest<Target> {
    pub fn bundles(&self) -> Vec<LinuxBundlerKind> {
        let bundles = if self.bundle.is_empty() {
            vec![LinuxBundlerKind::Deb]
        } else {
            self.bundle.clone()
        };
        let mut unique_bundles = Vec::with_capacity(bundles.len());

        for bundle in bundles {
            if !unique_bundles.contains(&bundle) {
                unique_bundles.push(bundle);
            }
        }

        unique_bundles
    }

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

    pub fn install_path(&self) -> Option<&str> {
        self.install_path.as_deref()
    }

    pub fn variable_sources(&self) -> Vec<&str> {
        self.install_path.iter().map(String::as_str).collect()
    }

    pub fn display_icon(&self) -> Option<&str> {
        self.display_icon.as_deref()
    }
}

impl LinuxPlatformManifest<LinuxTarget> {
    pub fn build(
        &self,
        targets: Vec<TargetManifest>,
        display_icon: Option<&str>,
    ) -> LinuxPlatformManifest<TargetManifest> {
        LinuxPlatformManifest {
            platform: "linux".to_owned(),
            targets,
            bundle: self.bundles(),
            install_path: self.install_path.clone(),
            bin_dir: self.bin_dir.clone(),
            files: Vec::new(),
            associated_files: self.associated_files.clone(),
            eulas: self.eulas.clone(),
            shortcuts: self.shortcuts.clone(),
            display_icon: display_icon.map(str::to_owned),
        }
    }
}

impl SourcePlatformManifest for LinuxPlatformManifest {
    fn name(&self) -> &'static str {
        "linux"
    }

    fn bin_dir(&self) -> &str {
        self.bin_dir()
    }

    fn install_path(&self) -> Option<&str> {
        self.install_path()
    }

    fn variable_sources(&self) -> Vec<&str> {
        self.variable_sources()
    }

    fn files(&self) -> &[FileMapping] {
        &self.files
    }

    fn display_icon(&self) -> Option<&str> {
        self.display_icon()
    }

    fn targets(&self) -> Vec<&'static str> {
        self.targets.iter().map(LinuxTarget::target).collect()
    }
}

impl PlatformManifest for LinuxPlatformManifest<TargetManifest> {
    fn platform(&self) -> &str {
        if self.platform.is_empty() {
            "linux"
        } else {
            &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 !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(install_path) = &self.install_path {
            output.push_str(&format!("    install path: {install_path}\n"));
        }

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

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

        if !self.associated_files.is_empty() {
            output.push_str("    associated files:\n");

            for file in &self.associated_files {
                let eula_report = if file.eula_report {
                    " (EULA report)"
                } else {
                    ""
                };
                output.push_str(&format!(
                    "      {:?}: {}{}\n",
                    file.kind, file.path, eula_report
                ));
            }
        }

        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
                ));
            }
        }
    }
}