forky_cli 0.2.0

Rust Utilities
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

use anyhow::Result;
use clap::Arg;
use clap::ArgAction;
use clap::Command;
use colorize::*;
use forky_fs::prelude::process::spawn_command_blocking;
use forky_fs::prelude::*;

pub struct WatchCommand;

impl Subcommand for WatchCommand {
	fn name(&self) -> &'static str { "watch" }
	fn about(&self) -> &'static str { "execute command on file change" }

	fn append_command(&self, command: Command) -> Command {
		// let cmd

		command
			.arg(
				Arg::new("cmd")
					.help(format!(
						"the space seperated command to run, ie {}",
						"forky watch -- echo howdy".green().bold()
					))
					.required(true)
					.action(ArgAction::Append),
			)
			.arg(
				Arg::new("watch")
					.help("paths to watch")
					.required(false)
					.short('w')
					.long("watch")
					.action(ArgAction::Append),
			)
			.arg(
				Arg::new("ignore")
					.help("paths to ignore")
					.required(false)
					.short('i')
					.long("ignore")
					.action(ArgAction::Append),
			)
			.arg(
				Arg::new("once")
					.help("only run once instead of watching indefinitely")
					.required(false)
					.long("once")
					.action(ArgAction::SetTrue),
			)
	}

	fn run(&self, args: &clap::ArgMatches) -> Result<()> {
		let cmd = args
			.get_many::<String>("cmd")
			.unwrap()
			.map(|s| s.as_str())
			.collect::<Vec<_>>();
		let watches = args
			.get_many::<String>("watch")
			.unwrap_or_default()
			.map(|s| s.as_str())
			.collect::<Vec<_>>();
		let ignores = args
			.get_many::<String>("ignore")
			.unwrap_or_default()
			.map(|s| s.as_str())
			.collect::<Vec<_>>();

		let watcher = FsWatcher::default()
			.with_watches(watches)
			.with_ignores(ignores);

		if args.get_flag("once") {
			watcher.block()?;
			// futures::executor::block_on(watcher.block_async())?;
			spawn_command_blocking(&cmd)
		} else {
			// futures::executor::block_on(watcher.watch_async(|_| spawn_command(&cmd)))
			watcher.watch(|_| spawn_command_blocking(&cmd))
		}
	}
}