bevy_args 3.0.0

bevy plugin to parse command line arguments and URL query parameters
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

#[cfg(target_arch = "wasm32")]
use std::collections::HashMap;

pub use clap::{
    Parser,
    ValueEnum,
};
pub use serde::{
    Deserialize,
    Serialize,
};


#[cfg(feature = "bevy")]
mod plugin;
#[cfg(feature = "bevy")]
pub use plugin::BevyArgsPlugin;


#[cfg(target_arch = "wasm32")]
fn parse_query_string(query: &str) -> HashMap<String, String> {
    query
        .split('&')
        .filter_map(|pair| {
            let mut iter = pair.splitn(2, '=');
            match (iter.next(), iter.next()) {
                (Some(key), Some(value)) => Some((key.to_string(), value.to_string())),
                _ => None,
            }
        })
        .collect()
}

#[cfg(target_arch = "wasm32")]
fn update_struct<R>(mut instance: R, query_map: HashMap<String, String>) -> R
where
    R: Serialize + for<'de> Deserialize<'de>,
{
    let mut instance_json = serde_json::to_value(&instance).unwrap();

    for (key, value) in query_map {
        if let Some(field) = instance_json.get_mut(&key) {
            let updated_value = match field {
                serde_json::Value::String(_) => serde_json::Value::String(value.clone()),
                serde_json::Value::Number(_) => {
                    if let Ok(num) = value.parse::<i64>() {
                        serde_json::Value::Number(num.into())
                    } else if let Ok(num) = value.parse::<f64>() {
                        serde_json::Value::Number(serde_json::Number::from_f64(num).unwrap())
                    } else {
                        serde_json::Value::String(value.clone())
                    }
                }
                serde_json::Value::Bool(_) => {
                    if let Ok(b) = value.parse::<bool>() {
                        serde_json::Value::Bool(b)
                    } else {
                        serde_json::Value::String(value.clone())
                    }
                }
                serde_json::Value::Null => serde_json::Value::String(value.clone()),
                _ => serde_json::Value::String(value.clone()), // Handle other types as strings for simplicity
            };
            *field = updated_value;
        }
    }

    instance = serde_json::from_value(instance_json).unwrap();
    instance
}


pub fn parse_args<R: Parser + Serialize + for<'a> Deserialize<'a>>() -> R {
    #[cfg(target_arch = "wasm32")]
    {
        let window = web_sys::window().unwrap();
        let location = window.location();
        let search = location.search().unwrap();

        let query_string = search.trim_start_matches('?');
        let query_map = parse_query_string(query_string);

        let default = R::parse();
        update_struct(default, query_map)
    }

    #[cfg(not(target_arch = "wasm32"))]
    R::parse()
}