cargo-crapapp 0.1.2

CLI for building CRAP app installers and self-contained app bundles
use anyhow::{Context, Result};
use serde::Serialize;

use crate::services::build_config_manifest::BuildConfigManifest;
use crate::services::cargo_package::CargoPackage;
use crate::services::icons::validate_icons;
use crate::services::manifest_file::{CrapManifest, PlatformManifest as _};
use crate::services::payload_file::payload_files;
use crate::services::platform_manifest::PlatformManifest;
use crate::services::target_manifest::{TargetManifest};

#[derive(Debug, Serialize)]
pub struct BuildManifest {
    pub app_name: String,
    pub version: String,
    pub build: BuildConfigManifest,
    pub platforms: Vec<PlatformManifest>,
}

impl BuildManifest {
    pub fn from_crap_manifest(manifest: &CrapManifest) -> Result<Self> {
        let cargo_package = CargoPackage::load()?;
        let mut platforms = Vec::new();

        for platform in manifest.platforms() {
            let files = payload_files(platform.files(), platform.install_path())?;
            validate_icons(platform.name(), platform.icons(), &cargo_package.binaries)?;
            let mut targets = Vec::new();
            let variable_sources = platform.variable_sources();

            for target in platform.targets() {
                targets.push(TargetManifest::new(
                    target,
                    &cargo_package.binaries,
                    platform.install_path(),
                    platform.bin_dir(),
                    &files,
                ));
            }

            platforms.push(PlatformManifest::new(
                platform.name(),
                &variable_sources,
                &files,
                platform.icons().to_vec(),
                targets,
            )?);
        }

        Ok(Self {
            app_name: cargo_package.name,
            version: cargo_package.version,
            build: BuildConfigManifest::from_crap_manifest(manifest),
            platforms,
        })
    }

    pub fn display(&self, formatter: BuildManifestFormatter) -> Result<String> {
        match formatter {
            BuildManifestFormatter::Text => Ok(self.display_text()),
            BuildManifestFormatter::Json => {
                serde_json::to_string_pretty(self).context("failed to render build manifest")
            }
        }
    }

    fn display_text(&self) -> String {
        let mut output = String::new();

        output.push_str(&format!("app: {}\n", self.app_name));
        output.push_str(&format!("version: {}\n", self.version));

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

        if !self.build.packages.is_empty() {
            output.push_str(&format!("packages: {}\n", self.build.packages.join(", ")));
        }

        if !self.build.features.is_empty() {
            output.push_str(&format!("features: {}\n", self.build.features.join(", ")));
        }

        output.push_str("platforms:\n");

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

            if !platform.variables.is_empty() {
                let variables = platform
                    .variables
                    .iter()
                    .map(|variable| variable.to_string())
                    .collect::<Vec<_>>()
                    .join(", ");

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

            for icon in &platform.icons {
                output.push_str(&format!("    icon: {} -> {}\n", icon.binary, icon.source));
            }

            for target in &platform.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
                    ));
                }
            }
        }

        output
    }
}

#[derive(Clone, Copy, Debug)]
pub enum BuildManifestFormatter {
    Text,
    Json,
}