dotter 0.12.14

A dotfile manager and templater written in rust
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

use std::convert::Infallible;
use std::sync::Arc;

use anyhow::{Context, Result};
use log::Level;
use watchexec::action::{Action, Outcome};
use watchexec::config::{InitConfig, RuntimeConfig};
use watchexec::filter::tagged::{Filter, Matcher, Op, Pattern, TaggedFilterer};
use watchexec::fs::Watcher;
use watchexec::handler::SyncFnHandler;
use watchexec::Watchexec;

use super::display_error;
use crate::args::Options;
use crate::deploy;

pub(crate) async fn watch(opt: Options) -> Result<()> {
    let mut init = InitConfig::default();
    let mut errors = false;
    init.on_error(SyncFnHandler::from(move |e| {
        if !errors && !log::log_enabled!(Level::Debug) {
            log::warn!("Watcher produced errors. Re-run with -vv to see them.");
            errors = true;
        }
        log::debug!("Watcher error: {e:#?}");
        Ok::<(), Infallible>(())
    }));

    let mut runtime = RuntimeConfig::default();
    runtime.file_watcher(Watcher::Native);
    runtime.pathset(["."]);

    let filter = TaggedFilterer::new(".", std::env::current_dir()?).unwrap();
    filter
        .add_filters(&[
            Filter {
                in_path: None,
                on: Matcher::Path,
                op: Op::NotGlob,
                pat: Pattern::Glob(format!("{}/", opt.cache_directory.display())),
                negate: false,
            },
            Filter {
                in_path: None,
                on: Matcher::Path,
                op: Op::NotGlob,
                pat: Pattern::Glob(opt.cache_file.to_string_lossy().into()),
                negate: false,
            },
            Filter {
                in_path: None,
                on: Matcher::Path,
                op: Op::NotGlob,
                pat: Pattern::Glob(".git/".into()),
                negate: false,
            },
            Filter {
                in_path: None,
                on: Matcher::Path,
                op: Op::NotEqual,
                pat: Pattern::Exact("DOTTER_SYMLINK_TEST".into()),
                negate: false,
            },
        ])
        .await?;
    runtime.filterer(Arc::new(filter));

    runtime.on_action(move |action: Action| {
        let opt = opt.clone();
        async move {
            if action.events.iter().any(|e| e.signals().next().is_some()) {
                action.outcome(Outcome::Exit);
                return Ok(());
            }

            println!("[Dotter] Deploying...");
            if let Err(e) = deploy::deploy(&opt) {
                display_error(e);
            }

            action.outcome(Outcome::if_running(Outcome::DoNothing, Outcome::Start));

            Ok::<(), Infallible>(())
        }
    });

    let we = Watchexec::new(init, runtime.clone())?;
    we.main().await.context("run watchexec main loop")??;
    Ok(())
}