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

use dip::{
    bevy::{
        app::AppExit,
        log::{self, LogPlugin},
    },
    prelude::*,
};
use serde::Deserialize;

fn main() {
    App::new()
        .add_plugin(CliPlugin::<AsyncAction>::application())
        .add_plugin(ActionPlugin)
        .add_plugin(AsyncActionPlugin)
        .add_plugin(LogPlugin)
        .add_startup_system(fetch_ip_address)
        .add_startup_system(fetch_user_agent)
        .add_system(handle_get_ip_address)
        .add_system(handle_get_user_agent)
        .run();
}

#[derive(CliPlugin, clap::Parser)]
struct Cli {
    #[clap(subcommand)]
    action: Action,
}

#[derive(SubcommandPlugin, clap::Subcommand, Clone)]
pub enum Action {
    IpAddress,
    UserAgent,
}

#[allow(dead_code)]
#[derive(Clone, Debug, Deserialize, Default)]
pub struct GetIpAddress {
    origin: String,
}

#[allow(dead_code)]
#[derive(Clone, Debug, Deserialize, Default)]
pub struct GetUserAgent {
    #[serde(rename = "user-agent")]
    user_agent: Option<String>,
}

#[async_action]
impl AsyncActionCreator {
    async fn get_ip_address() -> GetIpAddress {
        reqwest::get("https://httpbin.org/ip")
            .await
            .unwrap()
            .json::<GetIpAddress>()
            .await
            .unwrap()
    }

    async fn get_user_agent() -> GetUserAgent {
        static APP_USER_AGENT: &str =
            concat!(env!("CARGO_PKG_NAME"), "/", env!("CARGO_PKG_VERSION"),);
        let client = reqwest::Client::builder()
            .user_agent(APP_USER_AGENT)
            .build()
            .unwrap();

        client
            .get("https://httpbin.org/user-agent")
            .send()
            .await
            .unwrap()
            .json::<GetUserAgent>()
            .await
            .unwrap()
    }
}

fn fetch_ip_address(
    mut events: EventReader<IpAddressAction>,
    async_action: Res<AsyncActionPool<AsyncAction>>,
) {
    for _ in events.iter() {
        async_action.send(AsyncAction::get_ip_address());
    }
}

fn fetch_user_agent(
    mut events: EventReader<UserAgentAction>,
    async_action: Res<AsyncActionPool<AsyncAction>>,
) {
    for _ in events.iter() {
        async_action.send(AsyncAction::get_user_agent());
    }
}

fn handle_get_ip_address(
    mut actions: EventReader<GetIpAddress>,
    mut app_exit: EventWriter<AppExit>,
) {
    for action in actions.iter() {
        log::info!("{action:#?}");
        app_exit.send(AppExit);
    }
}

fn handle_get_user_agent(
    mut actions: EventReader<GetUserAgent>,
    mut app_exit: EventWriter<AppExit>,
) {
    for action in actions.iter() {
        log::info!("{action:#?}");
        app_exit.send(AppExit);
    }
}