Merge pull request #1033 from CraftSpider/update-deps

Update deps

Author: pkgw

Cargo.lock

@@ -84,9 +84,12 @@ tectonic_xdv = { path = "crates/xdv", version = "0.0.0-dev.0" }
 tectonic_xetex_layout = { path = "crates/xetex_layout", version = "0.0.0-dev.0" }
 tempfile = "^3.1"
 termcolor = "^1.1"
+tokio = "^1.0"
 toml = { version = "^0.7", optional = true }
 url = "^2.0"
-watchexec = "^1.15.3"
+watchexec = "^2.3.0"
+watchexec-filterer-globset = "1.2"
+watchexec-signals = "1.0"
 zip = { version = "^0.6", default-features = false, features = ["deflate"] }
 
 [features]
@@ -112,11 +115,10 @@ profile = []
 
 [dev-dependencies]
 filetime = "^0.2"
-futures = "0.1"
-headers = "0.2"
-hyper = "0.12"
+futures = "0.3"
+headers = "0.3"
+hyper = { version = "0.14", features = ["server"] }
 tempfile = "^3.1"
-tokio = "0.1.22"
 
 [package.metadata.vcpkg]
 git = "https://github.com/microsoft/vcpkg"

Cargo.toml

@@ -53,7 +53,6 @@ steps:
 # support in the test harness to wrap the invocations in `kcov` calls.
 - bash: |
     set -xeuo pipefail
-    p="$(pwd)"
     export TECTONIC_EXETEST_KCOV_RUNNER="kcov --include-path=$(pwd) --exclude-pattern=/tests/"
     cargo test --test executable
   displayName: Special-case executable tests

dist/azure-coverage.yml

@@ -4,7 +4,10 @@
 //! The "v2cli" command-line interface -- a "multitool" interface resembling
 //! Cargo, as compared to the classic "rustc-like" CLI.
 
-use std::{env, ffi::OsString, io::Write, path::PathBuf, process, str::FromStr};
+use std::{
+    convert::Infallible, env, ffi::OsString, io::Write, path::PathBuf, process, str::FromStr,
+    sync::Arc,
+};
 use structopt::{clap::AppSettings, StructOpt};
 use tectonic::{
     self,
@@ -19,9 +22,16 @@ use tectonic::{
 use tectonic_bridge_core::{SecuritySettings, SecurityStance};
 use tectonic_bundles::Bundle;
 use tectonic_docmodel::workspace::{Workspace, WorkspaceCreator};
-use tectonic_errors::Error as NewError;
 use tectonic_status_base::plain::PlainStatusBackend;
-use watchexec::run::OnBusyUpdate;
+use tokio::runtime;
+use watchexec::{
+    action::{Action, Outcome, PreSpawn},
+    command::{Command, Shell},
+    config::InitConfig,
+    Watchexec,
+};
+use watchexec_filterer_globset::GlobsetFilterer;
+use watchexec_signals::Signal;
 
 /// The main options for the "V2" command-line interface.
 #[derive(Debug, StructOpt)]
@@ -521,46 +531,100 @@ pub struct WatchCommand {
 impl WatchCommand {
     fn customize(&self, _cc: &mut CommandCustomizations) {}
 
-    fn execute(self, _config: PersistentConfig, status: &mut dyn StatusBackend) -> Result<i32> {
+    async fn execute_inner(self, status: &mut dyn StatusBackend) -> Result<i32> {
         let exe_name = crate::watch::get_trimmed_exe_name()
             .into_os_string()
             .into_string()
             .expect("Executable path wasn't valid UTF-8");
         let mut cmds = Vec::new();
         for x in self.execute.iter() {
-            let mut cmd = format!("{exe_name} -X ");
             let x = x.trim();
             if !x.is_empty() {
-                cmd.push_str(x);
+                let cmd = Command::Exec {
+                    prog: exe_name.clone(),
+                    args: vec!["-X".to_string(), x.to_string()],
+                };
                 cmds.push(cmd)
             }
         }
 
         if cmds.is_empty() {
-            cmds.push(format!("{exe_name} -X build"))
+            cmds.push(Command::Exec {
+                prog: exe_name,
+                args: vec!["-X".to_string(), "build".to_string()],
+            });
         }
 
-        let command = cmds.join(" && ");
-
-        let mut args = watchexec::config::ConfigBuilder::default();
-        let mut final_command = command.clone();
-        #[cfg(unix)]
-        final_command.push_str("; echo [Finished running. Exit status: $?]");
         #[cfg(windows)]
-        {
-            final_command.push_str(" & echo [Finished running. Exit status: %ERRORLEVEL%]");
-            args.shell(watchexec::Shell::Cmd);
-        }
-        #[cfg(not(any(unix, windows)))]
-        final_command.push_str(" ; echo [Finished running]");
+        let (shell, command) = (
+            Shell::Cmd,
+            "echo [Finished running. Exit status: %ERRORLEVEL%]",
+        );
+        #[cfg(unix)]
+        let (shell, command) = (
+            Shell::Unix("bash".to_string()),
+            "echo [Finished running. Exit status: $?]",
+        );
+
+        cmds.push(Command::Shell {
+            shell,
+            args: vec![],
+            command: command.to_string(),
+        });
+
+        let mut runtime_config = watchexec::config::RuntimeConfig::default();
+        runtime_config.commands(cmds);
+
+        let current_dir = env::current_dir()?;
+
+        let filter = GlobsetFilterer::new(
+            &current_dir,
+            [],
+            // Ignore build directory, and things like vim swap files
+            [("build/**".to_string(), None), ("*.swp".to_string(), None)],
+            [],
+            [],
+        )
+        .await
+        .unwrap();
+
+        runtime_config
+            .pathset([&current_dir])
+            .filterer(Arc::new(filter))
+            .on_pre_spawn(|pre_spawn: PreSpawn| async move {
+                println!("[Running `{}`]", pre_spawn.command);
+                Ok::<_, Infallible>(())
+            })
+            .on_action(|action: Action| async move {
+                for event in &*action.events {
+                    let is_kill = event.signals().any(|signal| {
+                        matches!(
+                            signal,
+                            Signal::Interrupt
+                                | Signal::Quit
+                                | Signal::Terminate
+                                | Signal::ForceStop
+                        )
+                    });
+                    if is_kill {
+                        action.outcome(Outcome::Exit);
+                        return Ok::<_, Infallible>(());
+                    }
+
+                    let paths = event.paths().collect::<Vec<_>>();
+                    if !paths.is_empty() {
+                        action.outcome(Outcome::IfRunning(
+                            Box::new(Outcome::DoNothing),
+                            Box::new(Outcome::Start),
+                        ));
+                        return Ok(());
+                    }
+                }
+                Ok(())
+            });
 
-        args.cmd(vec![final_command])
-            .paths(vec![env::current_dir()?])
-            .ignores(vec!["build".to_owned()])
-            .on_busy_update(OnBusyUpdate::Queue);
-        let args = args.build().map_err(NewError::from)?;
+        let exec_handler = Watchexec::new(InitConfig::default(), runtime_config);
 
-        let exec_handler = watchexec::run::ExecHandler::new(args);
         match exec_handler {
             Err(e) => {
                 tt_error!(
@@ -571,19 +635,19 @@ impl WatchCommand {
                 Ok(1)
             }
             Ok(exec_handler) => {
-                let handler = crate::watch::Watcher {
-                    command,
-                    inner: exec_handler,
-                };
-                if let Err(e) = watchexec::watch(&handler) {
-                    tt_error!(status, "failed to execute watch"; e.into());
-                    Ok(1)
-                } else {
-                    Ok(0)
-                }
+                exec_handler.main().await.unwrap().unwrap();
+                Ok(0)
             }
         }
     }
+
+    fn execute(self, _config: PersistentConfig, status: &mut dyn StatusBackend) -> Result<i32> {
+        let rt = runtime::Builder::new_multi_thread()
+            .enable_all()
+            .build()
+            .unwrap();
+        rt.block_on(self.execute_inner(status))
+    }
 }
 
 /// `new`: Create a new document project

src/bin/tectonic/v2cli.rs

@@ -1,33 +1,6 @@
 use std::env;
 use std::path::PathBuf;
 
-pub(crate) struct Watcher {
-    pub(crate) command: String,
-    pub(crate) inner: watchexec::run::ExecHandler,
-}
-
-impl watchexec::Handler for Watcher {
-    fn args(&self) -> watchexec::config::Config {
-        self.inner.args()
-    }
-
-    fn on_manual(&self) -> watchexec::error::Result<bool> {
-        self.start();
-        self.inner.on_manual()
-    }
-
-    fn on_update(&self, ops: &[watchexec::pathop::PathOp]) -> watchexec::error::Result<bool> {
-        self.start();
-        self.inner.on_update(ops)
-    }
-}
-
-impl Watcher {
-    fn start(&self) {
-        println!("[Running `{}`]", self.command)
-    }
-}
-
 /// Obtain the executable name without a prefix if the executable is available in the PATH, e.g.
 /// most cases. Otherwise, use the full path e.g. in development.
 pub(crate) fn get_trimmed_exe_name() -> PathBuf {

src/bin/tectonic/watch.rs

@@ -411,7 +411,7 @@ impl BridgeState {
         // Mark the input files as having been read, and we're done.
 
         for name in &read_files {
-            let mut summ = self.events.get_mut(name).unwrap();
+            let summ = self.events.get_mut(name).unwrap();
             summ.access_pattern = match summ.access_pattern {
                 AccessPattern::Written => AccessPattern::WrittenThenRead,
                 c => c, // identity mapping makes sense for remaining options