tomate 0.5.0

A command-line tool for the Pomodoro productivity system
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

//! Interact with Pomodoro timers

use crate::{hooks, time::Timer, Config, History, Status};
use anyhow::{anyhow, Context, Result};
use chrono::{prelude::*, TimeDelta};
use log::{info, warn};
use serde::{Deserialize, Serialize};

/// A Pomodoro timer
#[derive(Clone, Eq, PartialEq, Hash, Debug, Serialize, Deserialize)]
pub struct Pomodoro {
    #[serde(flatten)]
    timer: Timer,
    description: Option<String>,
    tags: Option<Vec<String>>,
    #[serde(default, with = "crate::time::datetimeopt::unix")]
    finished_at: Option<DateTime<Local>>,
}

impl Pomodoro {
    /// Create a new timer
    pub fn new(starts_at: DateTime<Local>, duration: TimeDelta) -> Self {
        let timer = Timer::new(starts_at, duration);
        Self {
            timer,
            finished_at: None,
            description: None,
            tags: None,
        }
    }

    /// Get the struct describing the time this Pomodoro is running
    pub fn timer(&self) -> &Timer {
        &self.timer
    }

    /// Get the description
    pub fn description(&self) -> Option<&str> {
        self.description.as_deref()
    }

    /// Set the description
    pub fn set_description(&mut self, description: &str) {
        self.description = Some(description.to_string());
    }

    /// Get the tags
    pub fn tags(&self) -> Option<&Vec<String>> {
        self.tags.as_ref()
    }

    /// Set the tags
    pub fn set_tags(&mut self, tags: Vec<String>) {
        self.tags = Some(tags);
    }

    /// Stop running this timer
    pub fn finish(&mut self, now: DateTime<Local>) {
        self.finished_at = Some(now);
    }

    /// Get the duration that this Pomodoro lasted before it was finished.
    ///
    /// This is the actual time between start and finish. If you want to get
    /// the duration the timer was set for, use the duration of this Pomodoro's [`Self::timer()`].
    pub fn duration(&self) -> Option<TimeDelta> {
        self.finished_at
            .map(|finished_at| finished_at - self.timer.starts_at())
    }
}

/// Starts a new Pomodoro timer.
pub fn start(
    config: &Config,
    duration: &Option<TimeDelta>,
    description: &Option<String>,
    tags: &[String],
) -> Result<()> {
    let dur = duration.unwrap_or(config.pomodoro_duration);
    let timer_seconds = dur.num_seconds();

    let mut pom = Pomodoro::new(Local::now(), dur);
    if let Some(desc) = description {
        pom.set_description(desc);
    }

    pom.set_tags(tags.to_vec());

    let status = Status::load(&config.state_file_path)?;

    let start_result = match status {
        Status::ShortBreak(_timer) => Err(anyhow!("You're currently taking a break!")),
        Status::LongBreak(_timer) => Err(anyhow!("You're currently taking a break!")),
        Status::Active(_pom) => Err(anyhow!("There is already an unfinished Pomodoro")),
        Status::Inactive => {
            let next_status = Status::Active(pom);
            next_status
                .save(&config.state_file_path)
                .with_context(|| "Unable to save new Pomodoro")?;

            hooks::Hook::PomodoroStart
                .run(&config.hooks_directory)
                .with_context(|| "Failed to run pomodoro start hook")
        }
    };

    start_result?;

    let systemd_output = std::process::Command::new("systemd-run")
        .args([
            "--user".to_string(),
            format!("--on-active={timer_seconds}"),
            "--timer-property=AccuracySec=100ms".to_string(),
            std::env::current_exe()?.to_str().unwrap().to_string(),
            "timer".to_string(),
            "check".to_string(),
        ])
        .output()
        .with_context(|| "Failed to schedule systemd timer")?;

    if let Ok(output_msg) = String::from_utf8(systemd_output.stderr) {
        info!("{}", &output_msg);
    } else {
        warn!(
            "{}",
            "systemd-run printed bytes to stderr that were not valid UTF-8"
        );
    }

    Ok(())
}

/// Stop the current Pomodoro timer and log it to the history file.
pub fn stop(config: &Config) -> Result<()> {
    let status = Status::load(&config.state_file_path)?;

    if let Status::Active(mut pom) = status {
        hooks::Hook::PomodoroEnd.run(&config.hooks_directory)?;

        pom.finish(Local::now());

        History::append(&pom, &config.history_file_path)?;

        crate::clear(config)?;
    }

    Ok(())
}