dip 0.2.1

Write cross-platform application with React-like declarative UI framework and scalable ECS architecture all in Rust.
Documentation 
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use crate::{
    cli::{action::BuildAction, async_action::AsyncAction},
    resource::tool::Tool,
};
use dip::{
    bevy::{
        app::{App, AppExit, Plugin},
        ecs::prelude::*,
        log,
    },
    core::task::AsyncActionPool,
};
use std::{fs, path::PathBuf, process::Command};

pub struct BuildActionPlugin;

impl Plugin for BuildActionPlugin {
    fn build(&self, app: &mut App) {
        app.add_event::<BuildApp>()
            .add_event::<CompileCss>()
            .add_system(handle_build)
            .add_system(compile_css.after(handle_build))
            .add_system(build_app.after(handle_build).after(compile_css));
    }
}
fn handle_build(
    mut actions: EventReader<BuildAction>,
    mut build_app: EventWriter<BuildApp>,
    mut compile_css: EventWriter<CompileCss>,
    async_action: Res<AsyncActionPool<AsyncAction>>,
) {
    for action in actions.iter() {
        let tailwind_config = PathBuf::from(&action.path).join("tailwind.config.js");

        if tailwind_config.is_file() {
            let tailwind = &Tool::Tailwind;

            if tailwind.bin_path().is_file() {
                compile_css.send(CompileCss {
                    action: action.clone(),
                    tool: tailwind.clone(),
                });
            } else {
                async_action.send(AsyncAction::install_and_build(tailwind, action.clone()));
            }
        } else {
            build_app.send(BuildApp {
                action: action.clone(),
            });
        }
    }
}

fn build_app(mut events: EventReader<BuildApp>, mut app_exit: EventWriter<AppExit>) {
    for BuildApp { action } in events.iter() {
        let mut cmd = Command::new("cargo");

        cmd.current_dir(fs::canonicalize(&action.path).unwrap())
            .args(["build"]);

        let output = cmd.output().expect("Could not execute cargo build");
        log::trace!("{output:?}");

        if output.status.success() {
            println!("Build finished");
        } else {
            println!("Failed to build project");
            println!("{}", String::from_utf8(output.stderr).unwrap());
        }

        app_exit.send(AppExit);
    }
}

#[derive(Clone, Debug)]
struct BuildApp {
    pub action: BuildAction,
}

#[derive(Clone, Debug)]
struct CompileCss {
    pub action: BuildAction,
    pub tool: Tool,
}

fn compile_css(
    mut events: EventReader<CompileCss>,
    mut build_app: EventWriter<BuildApp>,
    mut app_exit: EventWriter<AppExit>,
) {
    for CompileCss { action, tool } in events.iter() {
        let mut cmd = Command::new(&tool.bin_path_str());

        cmd.current_dir(fs::canonicalize(&action.path).unwrap());
        cmd.args([
            "-c",
            &action.config,
            "-i",
            &action.input,
            "-o",
            &action.output,
        ]);

        if action.watch {
            cmd.arg("-w");
        }

        let output = cmd
            .output()
            .expect("Could not execute compilation for Tailwind CSS");
        log::trace!("{output:?}");

        if output.status.success() {
            println!("CSS compiled");

            build_app.send(BuildApp {
                action: action.clone(),
            })
        } else {
            println!("Failed to compile Tailwind CSS");
            println!("{}", String::from_utf8(output.stderr).unwrap());

            app_exit.send(AppExit);
        }
    }
}