with-watch 0.1.5

Watch command inputs and rerun commands when they change
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

use std::{io, path::PathBuf};

use thiserror::Error;

pub type Result<T> = std::result::Result<T, WithWatchError>;

#[derive(Debug, Error)]
pub enum WithWatchError {
    #[error(
        "Provide a delegated utility, `--shell <expr>`, or `exec --input <glob>... -- <command> \
         ...`."
    )]
    MissingCommand,
    #[error("`--shell` cannot be combined with delegated argv or the `exec` subcommand.")]
    ConflictingModes,
    #[error("`--shell` requires a non-empty shell expression.")]
    EmptyShellExpression,
    #[error("`exec` requires a delegated command after `--`.")]
    MissingExecCommand,
    #[error(
        "No watch inputs could be inferred from the delegated command. Use `with-watch exec \
         --input <glob>... -- <command> [args...]`."
    )]
    NoWatchInputs,
    #[error("Failed to determine the current working directory: {0}")]
    CurrentDirectory(#[source] io::Error),
    #[error("Failed to parse shell expression: {message}")]
    ShellParse { message: String },
    #[error("Shell control-flow is out of scope for with-watch v1: {construct}")]
    UnsupportedShellConstruct { construct: String },
    #[error("Failed to compile glob pattern `{pattern}`: {message}")]
    InvalidGlob { pattern: String, message: String },
    #[error("Could not derive a watch anchor for `{path}`.")]
    MissingWatchAnchor { path: PathBuf },
    #[error("Failed to read metadata for `{path}`: {source}")]
    Metadata {
        path: PathBuf,
        #[source]
        source: io::Error,
    },
    #[error("Failed to read `{path}` while hashing: {source}")]
    HashRead {
        path: PathBuf,
        #[source]
        source: io::Error,
    },
    #[error("Failed to create a filesystem watcher: {0}")]
    WatcherCreate(#[source] notify::Error),
    #[error("Failed to watch `{path}` recursively: {source}")]
    WatchPath {
        path: PathBuf,
        #[source]
        source: notify::Error,
    },
    #[error("Failed to spawn `{command}`: {source}")]
    Spawn {
        command: String,
        #[source]
        source: io::Error,
    },
    #[error("Failed while waiting for `{command}`: {source}")]
    Wait {
        command: String,
        #[source]
        source: io::Error,
    },
    #[error("Failed to refresh stdout before running the delegated command: {0}")]
    StdoutRefresh(#[source] io::Error),
    #[error("`--shell` execution is only supported on Unix-like platforms.")]
    UnsupportedShellPlatform,
}

impl WithWatchError {
    pub fn exit_code(&self) -> i32 {
        match self {
            Self::MissingCommand
            | Self::ConflictingModes
            | Self::EmptyShellExpression
            | Self::MissingExecCommand
            | Self::NoWatchInputs
            | Self::ShellParse { .. }
            | Self::UnsupportedShellConstruct { .. }
            | Self::InvalidGlob { .. }
            | Self::MissingWatchAnchor { .. }
            | Self::UnsupportedShellPlatform => 2,
            Self::CurrentDirectory(_)
            | Self::Metadata { .. }
            | Self::HashRead { .. }
            | Self::WatcherCreate(_)
            | Self::WatchPath { .. }
            | Self::Spawn { .. }
            | Self::Wait { .. }
            | Self::StdoutRefresh(_) => 1,
        }
    }
}