genact 1.5.1

A nonsense activity generator
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

#[cfg(not(target_arch = "wasm32"))]
use clap::{Parser, builder::PossibleValuesParser};

use crate::modules::ALL_MODULES;

#[cfg(not(target_arch = "wasm32"))]
fn parse_speed_factor(s: &str) -> Result<f32, String> {
    let value_as_float = s.parse::<f32>().map_err(|e| e.to_string())?;
    if value_as_float < 0.01 {
        return Err("Speed factor must be larger than 0.01".to_string());
    }
    Ok(value_as_float)
}

#[cfg(not(target_arch = "wasm32"))]
fn parse_min_1(s: &str) -> Result<u32, String> {
    let value_as_u32 = s.parse::<u32>().map_err(|e| e.to_string())?;
    if value_as_u32 == 0 {
        return Err("Must be larger than 0".to_string());
    }
    Ok(value_as_u32)
}

#[cfg(not(target_arch = "wasm32"))]
#[derive(Parser)]
#[clap(name = "genact", author, about, version)]
pub struct AppConfig {
    /// List available modules
    #[clap(short, long = "list-modules")]
    pub list_modules_and_exit: bool,

    /// Run only these modules
    #[clap(short, long, value_parser = PossibleValuesParser::new(&ALL_MODULES.keys().cloned().collect::<Vec<_>>()))]
    pub modules: Vec<String>,

    /// Global speed factor
    #[clap(short, long, default_value = "1", value_parser = parse_speed_factor)]
    pub speed_factor: f32,

    /// Instantly print this many lines
    #[clap(short, long = "instant-print-lines", default_value = "0")]
    pub instant_print_lines: u32,

    // platforms supported by `keepawake`
    #[cfg(any(target_os = "linux", target_os = "macos", target_os = "windows"))]
    /// Keep the computer awake and the display on while genact is running
    #[clap(long)]
    pub inhibit: bool,

    /// Exit after running for this long (format example: 2h10min)
    #[clap(long, value_parser = humantime::parse_duration)]
    pub exit_after_time: Option<instant::Duration>,

    /// Exit after running this many modules
    #[clap(long, value_parser = parse_min_1)]
    pub exit_after_modules: Option<u32>,

    /// Generate completion file for a shell
    #[clap(long = "print-completions", value_name = "shell")]
    pub print_completions: Option<clap_complete::Shell>,

    /// Generate man page
    #[clap(long = "print-manpage")]
    pub print_manpage: bool,
}

#[cfg(target_arch = "wasm32")]
pub struct AppConfig {
    /// Run only these modules
    pub modules: Vec<String>,

    /// Global speed factor
    pub speed_factor: f32,

    /// Instantly print this many lines
    pub instant_print_lines: u32,
}

impl AppConfig {
    /// Check whether it's time to stop running.
    pub fn should_exit(&self) -> bool {
        // Check whether CTRL-C was pressed.
        #[cfg(not(target_arch = "wasm32"))]
        {
            use crate::{MODULES_RAN, STARTED_AT};
            use std::sync::atomic::Ordering;

            // Check if maximum running time is exceeded.
            if let Some(eat) = self.exit_after_time
                && STARTED_AT.elapsed() > eat
            {
                return true;
            }

            // Check if maximum number of module runs has been reached.
            if let Some(eam) = self.exit_after_modules
                && MODULES_RAN.load(Ordering::SeqCst) >= eam
            {
                return true;
            }
        }

        false
    }
}

#[cfg(not(target_arch = "wasm32"))]
pub fn parse_args() -> AppConfig {
    let mut args = AppConfig::parse();

    if args.modules.is_empty() {
        args.modules = ALL_MODULES.keys().map(|m| m.to_string()).collect();
    };
    args
}

#[cfg(target_arch = "wasm32")]
pub fn parse_args() -> AppConfig {
    use url::Url;

    let mut temp_modules = vec![];
    let window = web_sys::window().expect("no global `window` exists");
    let location = window.location();
    let parsed_url = Url::parse(&location.href().unwrap()).unwrap();
    let mut pairs = parsed_url.query_pairs();
    let filtered_modules = pairs.filter(|&(ref k, _)| k == "module");
    for (_, query_val) in filtered_modules {
        let actual_val = &&*query_val;
        if ALL_MODULES.keys().any(|x| x == actual_val) {
            temp_modules.push(actual_val.to_string());
        }
    }
    let speed_factor: f32 = pairs
        .find(|&(ref k, _)| k == "speed-factor")
        .map(|(_, v)| v.parse::<f32>().unwrap_or(1.0))
        .unwrap_or(1.0);

    let instant_print_lines: u32 = pairs
        .find(|&(ref k, _)| k == "instant-print-lines")
        .map(|(_, v)| v.parse::<u32>().unwrap_or(0))
        .unwrap_or(0);

    let modules_to_run = if temp_modules.is_empty() {
        ALL_MODULES.keys().map(|m| m.to_string()).collect()
    } else {
        temp_modules
    };

    AppConfig {
        modules: modules_to_run,
        speed_factor,
        instant_print_lines,
    }
}