Struct Args 

pub struct Args {
    pub program: Vec<String>,
    pub manual: bool,
    pub completions: Option<ShellCompletion>,
    pub only_emit_events: bool,
    pub once: bool,
    pub command: CommandArgs,
    pub events: EventsArgs,
    pub filtering: FilteringArgs,
    pub logging: LoggingArgs,
    pub output: OutputArgs,
}

Execute commands when watched files change.

Recursively monitors the current directory for changes, executing the command when a filesystem change is detected (among other event sources). By default, watchexec uses efficient kernel-level mechanisms to watch for changes.

At startup, the specified command is run once, and watchexec begins monitoring for changes.

Events are debounced and checked using a variety of mechanisms, which you can control using the flags in the Filtering section. The order of execution is: internal prioritisation (signals come before everything else, and SIGINT/SIGTERM are processed even more urgently), then file event kind (--fs-events), then files explicitly watched with -w, then ignores (--ignore and co), then filters (which includes --exts), then filter programs.

Examples:

Rebuild a project when source files change:

$ watchexec make

Watch all HTML, CSS, and JavaScript files for changes:

$ watchexec -e html,css,js make

Run tests when source files change, clearing the screen each time:

$ watchexec -c make test

Launch and restart a node.js server:

$ watchexec -r node app.js

Watch lib and src directories for changes, rebuilding each time:

$ watchexec -w lib -w src make

Fields

program: Vec<String>

Command (program and arguments) to run on changes

It’s run when events pass filters and the debounce period (and once at startup unless ‘–postpone’ is given). If you pass flags to the command, you should separate it with – though that is not strictly required.

Examples:

$ watchexec -w src npm run build

$ watchexec -w src – rsync -a src dest

Take care when using globs or other shell expansions in the command. Your shell may expand them before ever passing them to Watchexec, and the results may not be what you expect. Compare:

$ watchexec echo src/*.rs

$ watchexec echo ‘src/*.rs’

$ watchexec –shell=none echo ‘src/*.rs’

Behaviour depends on the value of ‘–shell’: for all except ‘none’, every part of the command is joined together into one string with a single ascii space character, and given to the shell as described in the help for ‘–shell’. For ‘none’, each distinct element the command is passed as per the execvp(3) convention: first argument is the program, as a path or searched for in the ‘PATH’ environment variable, rest are arguments.

manual: bool

Show the manual page

This shows the manual page for Watchexec, if the output is a terminal and the ‘man’ program is available. If not, the manual page is printed to stdout in ROFF format (suitable for writing to a watchexec.1 file).

completions: Option<ShellCompletion>

Generate a shell completions script

Provides a completions script or configuration for the given shell. If Watchexec is not distributed with pre-generated completions, you can use this to generate them yourself.

Supported shells: bash, elvish, fish, nu, powershell, zsh.

only_emit_events: bool

Only emit events to stdout, run no commands.

This is a convenience option for using Watchexec as a file watcher, without running any commands. It is almost equivalent to using cat as the command, except that it will not spawn a new process for each event.

This option implies --emit-events-to=json-stdio; you may also use the text mode by specifying --emit-events-to=stdio.

once: bool

Testing only: exit Watchexec after the first run and return the command’s exit code

command: CommandArgs

events: EventsArgs

filtering: FilteringArgs

logging: LoggingArgs

output: OutputArgs

Trait Implementations

impl Args for Args

fn group_id() -> Option<Id>

Report the ArgGroup::id for this set of arguments

fn augment_args<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate Self via FromArgMatches::from_arg_matches_mut

fn augment_args_for_update<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate self via FromArgMatches::update_from_arg_matches_mut

impl Clone for Args

fn clone(&self) -> Args

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl CommandFactory for Args

fn command<'b>() -> Command

Build a Command that can instantiate Self.

fn command_for_update<'b>() -> Command

Build a Command that can update self.

impl Debug for Args

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromArgMatches for Args

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Parser for Args

fn parse() -> Self

Parse from std::env::args_os(), exit on error.

fn try_parse() -> Result<Self, Error>

Parse from std::env::args_os(), return Err on error.

fn parse_from<I, T>(itr: I) -> Self

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, exit on error.

fn try_parse_from<I, T>(itr: I) -> Result<Self, Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, return Err on error.

fn update_from<I, T>(&mut self, itr: I)

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, exit on error.

fn try_update_from<I, T>(&mut self, itr: I) -> Result<(), Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, return Err on error.