thirdshift 0.16.5

Turn a GitHub issue into a ready-for-review pull request, unattended
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

//! Dependencies that can change a live observation without a record write.
use std::collections::BTreeSet;
use std::path::PathBuf;
use std::time::Duration;

use anyhow::Result;
use chrono::{DateTime, Local};

use super::super::reading::{Command, Entry, Snapshot};
use crate::config::UserConfig;

pub(crate) use super::super::reading::Writer as Process;

#[derive(Default, Debug)]
pub(crate) struct Watching {
    pub processes: Vec<Process>,
    pub paths: BTreeSet<PathBuf>,
    pub deadline: Option<Duration>,
}

pub(crate) fn watching(config: &UserConfig) -> Result<Watching> {
    let now = Local::now();
    let snapshot = Snapshot::load_with_silence(&config.logs_dir, now, config.silent_interval)?;
    let mut watching = Watching::default();
    let kept = crate::logs::github::load(&config.logs_dir);
    watching.deadline = kept.next_warning_change();
    if let Some(at) = snapshot
        .evaluate_inbox(config.inbox_days, &kept)
        .next_change()
    {
        deadline(at, now, &mut watching);
    }
    for entry in snapshot.entries() {
        if let Entry::Record(command) = entry {
            collect(command, now, &mut watching);
        }
    }
    Ok(watching)
}

fn collect(command: &Command, now: DateTime<Local>, watching: &mut Watching) {
    let process = Process::capture(&command.record);
    if process.live() {
        watching.processes.push(process);
        watching
            .paths
            .extend(command.activity_paths().map(PathBuf::from));
    }
    if command.state == "live"
        && let Some(at) = command.next_health_change
    {
        deadline(at, now, watching);
    }
    for child in command.children.iter().chain(&command.dispatched) {
        collect(child, now, watching);
    }
}

fn deadline(at: DateTime<Local>, now: DateTime<Local>, watching: &mut Watching) {
    if let Ok(delay) = (at - now).to_std()
        && !delay.is_zero()
    {
        watching.deadline = Some(watching.deadline.map_or(delay, |old| old.min(delay)));
    }
}