trimsec 2.1.1

Calculate time saved on using speed multipliers.
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

use clap::Args;

use crate::formatting::*;
use crate::{commands::Runnable, core::time::TimeConfig};
use anyhow::{Result, bail};

#[derive(Debug, Default, Args)]
pub struct TrimCmd {
    /// Duration of the content (e.g. 1h2m1s, 1h1s, 2d49s).
    pub duration: String,
    /// The speed multiplier (e.g. 1.25x, 1.25).
    pub multiplier: String,
}

impl Runnable for TrimCmd {
    fn run(self) -> Result<()> {
        let config = TimeConfig::new(&self.duration, &self.multiplier);

        match config {
            Ok(cfg) => {
                let trimmed = cfg.trim();

                match trimmed {
                    Ok((new_duration, time_saved, splits)) => {
                        if time_saved > 0.0 {
                            let parsed = crate::core::time::parse_time(new_duration);

                            let message = format!(
                                "\nFinishes in: {} ",
                                if splits > 1 {
                                    format!("{parsed} (all {splits} durations)")
                                } else {
                                    parsed
                                }
                            );
                            println!("{}", message);
                        } else {
                            println!("No time saved. Would finish in linear time.");
                            return Ok(());
                        }

                        let remaining = crate::core::time::calculate_remaining(new_duration);
                        println!(
                            "Time in day left: {} ",
                            if remaining == 0.0 {
                                "0s".to_string()
                            } else {
                                crate::core::time::parse_time(remaining)
                            }
                        );

                        if time_saved > 0.0 {
                            let parsed = crate::core::time::parse_time(time_saved);
                            println!("{GREEN}{BOLD}Saved {parsed}!{RESET}\n");
                        }
                    }
                    Err(e) => bail!("trim error: {e}"),
                }
            }
            Err(e) => bail!("time configuration error: {e}"),
        }
        Ok(())
    }
}