cargo-crapapp 0.4.2

Cargo subcommand for building CRAP app installers and self-contained app bundles
Documentation
use std::fs;
use std::path::Path;

use anyhow::Context;

use crate::build_manifest::BuildManifest;
use crate::bundlers::LinuxBundlerKind;
use crate::linux_installer::deb::{self, DebSpec};
use crate::linux_installer::prepare_payload;
use crate::package_metadata::{description, homepage, summary};
use crate::platform_manifests::LinuxPlatformManifest;
use crate::target_manifest::TargetManifest;

pub struct LinuxDebBundler {}

impl LinuxDebBundler {
    pub fn bundle(
        build_manifest: &BuildManifest,
        build_dir: &Path,
        platform_manifest: &LinuxPlatformManifest<TargetManifest>,
        target_manifest: &TargetManifest,
        bundle: &LinuxBundlerKind,
    ) -> anyhow::Result<()> {
        let target_dir = build_dir
            .join(&platform_manifest.platform)
            .join(&target_manifest.target)
            .join(bundle.to_string());

        if target_dir.exists() {
            fs::remove_dir_all(&target_dir)
                .with_context(|| format!("failed to remove {}", target_dir.display()))?;
        }
        fs::create_dir_all(&target_dir)
            .with_context(|| format!("failed to create {}", target_dir.display()))?;

        let payload = prepare_payload(build_manifest, platform_manifest, target_manifest)?;
        let output = target_dir.join(format!("{}.deb", payload.package));
        let architecture = if target_manifest.target.starts_with("aarch64-") {
            "arm64"
        } else {
            "amd64"
        };
        let spec = DebSpec {
            package: payload.package,
            version: build_manifest.version.clone(),
            bundled_at: build_manifest.bundled_at.clone(),
            maintainer: build_manifest
                .build
                .publisher
                .clone()
                .unwrap_or_else(|| "unknown".to_owned()),
            summary: summary(build_manifest),
            description: description(build_manifest),
            homepage: homepage(build_manifest).map(str::to_owned),
            architecture: architecture.to_owned(),
            files: payload.files,
            generated_files: payload.generated_files,
            associated_files: platform_manifest.associated_files.clone(),
            eulas: platform_manifest.eulas.clone(),
        };

        deb::build(&spec, &output)
            .with_context(|| format!("failed to write {}", output.display()))?;

        Ok(())
    }
}