cargo-crapapp 0.4.2

Cargo subcommand for building CRAP app installers and self-contained app bundles
Documentation
use serde::{Deserialize, Serialize};

use crate::bundlers::WindowsBundlerKind;
use crate::{
    build_variable::{BuildVariable, get_platform_variables},
    manifest_file::{AssociatedFile, EulaFile, FileMapping, ShortcutMapping, WindowsTarget},
    payload_file::PayloadFile,
    platform_manifest::PlatformManifest,
    target_manifest::TargetManifest,
};

#[derive(Debug, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
#[serde(bound(
    deserialize = "Target: Deserialize<'de>",
    serialize = "Target: Serialize"
))]
pub struct WindowsPlatformManifest<Target = WindowsTarget> {
    #[serde(default)]
    pub platform: String,
    #[serde(default)]
    pub targets: Vec<Target>,
    #[serde(
        default,
        deserialize_with = "crate::manifest_file::deserialize_windows_bundles"
    )]
    pub bundle: Vec<WindowsBundlerKind>,
    pub install_path: Option<String>,
    pub bin_dir: Option<String>,
    /// Directories to append to PATH from the MSI. An empty list defaults to
    /// the installation root.
    #[serde(default)]
    pub path_entries: Vec<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)]
    pub shortcuts: Vec<ShortcutMapping>,
    pub display_icon: Option<String>,
    #[serde(skip, default)]
    pub display_icon_source: Option<String>,
    #[serde(skip, default)]
    pub variables: Vec<BuildVariable>,
}

impl<Target> WindowsPlatformManifest<Target> {
    pub fn bundles(&self) -> Vec<WindowsBundlerKind> {
        let bundles = if self.bundle.is_empty() {
            vec![WindowsBundlerKind::Msi]
        } 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
    }
}

impl WindowsPlatformManifest {
    pub fn bin_dir(&self) -> &str {
        self.bin_dir.as_deref().unwrap_or("")
    }

    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)
            .chain(self.associated_files.iter().map(|file| file.path.as_str()))
            .collect()
    }

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

    pub fn build(
        &self,
        files: &[PayloadFile],
        targets: Vec<TargetManifest>,
        variable_sources: &[&str],
        display_icon: Option<&str>,
        display_icon_source: Option<&str>,
    ) -> anyhow::Result<WindowsPlatformManifest<TargetManifest>> {
        Ok(WindowsPlatformManifest {
            platform: "windows".to_owned(),
            targets,
            bundle: self.bundles(),
            install_path: self.install_path.clone(),
            bin_dir: self.bin_dir.clone(),
            path_entries: self.path_entries.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),
            display_icon_source: display_icon_source.map(str::to_owned),
            variables: get_platform_variables(variable_sources, files)?,
        })
    }
}

impl PlatformManifest for WindowsPlatformManifest<TargetManifest> {
    fn platform(&self) -> &str {
        if self.platform.is_empty() {
            "windows"
        } 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 !self.variables.is_empty() {
            let variables = self
                .variables
                .iter()
                .map(|variable| variable.to_string())
                .collect::<Vec<_>>()
                .join(", ");

            output.push_str(&format!("    variables: {variables}\n"));
        }

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

            if !target.shortcuts.is_empty() {
                output.push_str("      shortcuts:\n");

                for shortcut in &target.shortcuts {
                    output.push_str(&format!("        {} -> {}", shortcut.name, shortcut.target));

                    if let Some(directory) = &shortcut.directory {
                        output.push_str(&format!(" ({directory})"));
                    }

                    if let Some(icon) = &shortcut.icon {
                        output.push_str(&format!(" [icon: {icon}]"));
                    }

                    output.push('\n');
                }
            }
        }
    }
}