waterui-cli 0.1.4

Cross-platform tooling for WaterUI applications
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

//! Web toolchain checks and installations.

use color_eyre::eyre;

use crate::{
    toolchain::{Installation, Toolchain, ToolchainError},
    utils::{run_command, run_command_output_os, which},
};

/// Rust `wasm32-unknown-unknown` target support.
#[derive(Debug, Clone, Copy, Default)]
pub struct Wasm32UnknownUnknownTarget;

/// Installation plan for the Rust wasm target.
#[derive(Debug, Clone, Copy, Default)]
pub struct Wasm32UnknownUnknownTargetInstallation;

impl Toolchain for Wasm32UnknownUnknownTarget {
    type Installation = Wasm32UnknownUnknownTargetInstallation;

    async fn check(&self) -> Result<(), ToolchainError<Self::Installation>> {
        if which("rustup").await.is_err() {
            return Err(ToolchainError::unfixable(
                "rustup is not installed or not found in PATH",
                "Install Rust with rustup from https://rustup.rs/ and re-run the command.",
            ));
        }

        let output = run_command_output_os("rustup", ["target", "list", "--installed"]).await;
        let output = match output {
            Ok(output) => output,
            Err(error) => {
                return Err(ToolchainError::unfixable(
                    format!("failed to query installed rustup targets: {error}"),
                    "Ensure rustup is healthy, then run `rustup target add wasm32-unknown-unknown` manually.",
                ));
            }
        };

        if !output.status.success() {
            return Err(ToolchainError::unfixable(
                format!(
                    "rustup target query failed: {}",
                    String::from_utf8_lossy(&output.stderr).trim()
                ),
                "Ensure rustup is healthy, then run `rustup target add wasm32-unknown-unknown` manually.",
            ));
        }

        let installed = String::from_utf8_lossy(&output.stdout);
        if installed
            .lines()
            .any(|line| line.trim() == "wasm32-unknown-unknown")
        {
            Ok(())
        } else {
            Err(ToolchainError::Fixable(
                Wasm32UnknownUnknownTargetInstallation,
            ))
        }
    }
}

impl Installation for Wasm32UnknownUnknownTargetInstallation {
    type Error = eyre::Report;

    async fn install(&self) -> Result<(), Self::Error> {
        run_command("rustup", ["target", "add", "wasm32-unknown-unknown"])
            .await
            .map(|_| ())
    }
}

/// `wasm-pack` binary for packaging browser bundles.
#[derive(Debug, Clone, Copy, Default)]
pub struct WasmPack;

/// Installation plan for `wasm-pack`.
#[derive(Debug, Clone, Copy, Default)]
pub struct WasmPackInstallation;

impl Toolchain for WasmPack {
    type Installation = WasmPackInstallation;

    async fn check(&self) -> Result<(), ToolchainError<Self::Installation>> {
        if which("wasm-pack").await.is_ok() {
            Ok(())
        } else {
            Err(ToolchainError::Fixable(WasmPackInstallation))
        }
    }
}

impl Installation for WasmPackInstallation {
    type Error = eyre::Report;

    async fn install(&self) -> Result<(), Self::Error> {
        run_command("cargo", ["install", "wasm-pack"])
            .await
            .map(|_| ())
    }
}

/// Composite toolchain for Web/WASM support.
pub type WebToolchain = (Wasm32UnknownUnknownTarget, WasmPack);