Merge pull request #54 from Canop/backtrace

Use the 't' key to toggle running cargo with backtrace

Author: Canop

CHANGELOG.md

@@ -1,3 +1,6 @@
+### next
+- propose to toggle backtraces when suggestion is found in cargo's output
+
 <a name="v1.1.8"></a>
 ### v1.1.8 - 2021/07/31
 - move to more recent versions of some crates - Fix #51

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "bacon"
-version = "1.1.8"
+version = "1.1.9-dev"
 authors = ["dystroy <[email protected]>"]
 repository = "https://github.com/Canop/bacon"
 description = "background rust compiler"
@@ -16,14 +16,14 @@ anyhow = "1.0"
 cargo_metadata = "0.14"
 cli-log = "2.0"
 crossbeam = "0.8"
-crossterm = "0.20"
+crossterm = "0.21"
 directories-next = "2.0"
 minimad = "0.8"
 notify = "5.0.0-pre.11"
 lazy-regex = "2.2.1"
 log = "0.4"
 serde = { version = "1.0", features = ["derive"] }
-termimad = "0.14"
+termimad = "0.16"
 toml = "0.5"
 unicode-width = "0.1.8"
 vte = "0.8"

Cargo.toml

@@ -39,7 +39,7 @@ or
 
     bacon ../broot
 
-### check all targets (tests, examples, etc)
+### check all targets (tests, examples, benches, etc)
 
     bacon --job check-all
 
@@ -129,6 +129,16 @@ Similarly you don't have to stop bacon when you want to use cargo to build the a
 
 Bacon is efficient and doesn't work when there's no notification.
 
+### Can I have all code always checked, including tests, benches and examples ?
+
+You can set the dedicated `check-all` job as as default in the bacon.toml file:
+
+```TOML
+default_job = "check-all"
+```
+
+Similarly, if your test units are fast enough, you may run them as default, either by editing the default job, by pointing to a new default job, or by creating a new one.
+
 ### What are the supported platforms ?
 
 It works on all decent terminals on Linux, Max OSX and Windows.
@@ -151,7 +161,7 @@ A solution is to add this to your init.vim file:
 
 	set nowritebackup
 
-This doesn't prevent vim from keeping copies during editions, it just changes the behavior of the write operation.
+This doesn't prevent vim from keeping copies during editions, it just changes the behavior of the write operation and has no practical downside.
 
 ### Can I get backtraces in tests ?
 

README.md

@@ -24,7 +24,7 @@ pub fn run(w: &mut W, mission: Mission) -> Result<()> {
     mission.add_watchs(&mut watcher)?;
 
     let executor = Executor::new(&mission)?;
-    executor.start()?; // first computation
+    executor.start(state.new_task())?; // first computation
 
     let event_source = EventSource::new()?;
     let user_events = event_source.receiver();
@@ -59,6 +59,16 @@ pub fn run(w: &mut W, mission: Mission) -> Result<()> {
                                 state.toggle_wrap_mode();
                                 state.draw(w)?;
                             }
+                            (Char('t'), KeyModifiers::NONE) => {
+                                debug!("user toggles backtraces");
+                                state.toggle_backtrace();
+                                if let Err(e) = executor.start(state.new_task()) {
+                                    debug!("error sending task: {}", e);
+                                } else {
+                                    state.computation_starts();
+                                }
+                                state.draw(w)?;
+                            }
                             (Home, _) => { state.scroll(w, ScrollCommand::Top)?; }
                             (End, _) => { state.scroll(w, ScrollCommand::Bottom)?; }
                             (Up, _) => { state.scroll(w, ScrollCommand::Lines(-1))?; }
@@ -88,7 +98,7 @@ pub fn run(w: &mut W, mission: Mission) -> Result<()> {
             }
             recv(watch_receiver) -> _ => {
                 debug!("got a watcher event");
-                if let Err(e) = executor.start() {
+                if let Err(e) = executor.start(state.new_task()) {
                     debug!("error sending task: {}", e);
                 } else {
                     state.computation_starts();

src/app.rs

@@ -15,29 +15,39 @@ use {
 /// Channel sizes are designed to avoid useless computations.
 pub struct Executor {
     pub line_receiver: Receiver<CommandExecInfo>,
-    task_sender: Sender<()>,
+    task_sender: Sender<Task>,
     stop_sender: Sender<()>, // signal for stopping the thread
     thread: thread::JoinHandle<()>,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
+pub struct Task {
+    pub backtrace: bool,
+}
+
 impl Executor {
     /// launch the commands, sends the lines of its stderr on the
     /// line channel.
     /// If `with_stdout` captures and send also its stdout.
     pub fn new(mission: &Mission) -> Result<Self> {
         let mut command = mission.get_command();
         let with_stdout = mission.need_stdout();
-        let (task_sender, task_receiver) = bounded(1);
+        let (task_sender, task_receiver) = bounded::<Task>(1);
         let (stop_sender, stop_receiver) = bounded(0);
         let (line_sender, line_receiver) = unbounded();
+        command
+            .stderr(Stdio::piped())
+            .stdout(if with_stdout { Stdio::piped() } else { Stdio::null() });
         let thread = thread::spawn(move || {
             loop {
                 select! {
-                    recv(task_receiver) -> _ => {
-                        debug!("starting task");
-                        command
-                            .stderr(Stdio::piped())
-                            .stdout(if with_stdout { Stdio::piped() } else { Stdio::null() });
+                    recv(task_receiver) -> task => {
+                        let task = task.unwrap();
+                        debug!("starting task {:?}", task);
+                        command.env(
+                            "RUST_BACKTRACE",
+                            if task.backtrace { "1" } else { "0" },
+                        );
                         let child = command.spawn();
                         let mut child = match child {
                             Ok(child) => child,
@@ -163,8 +173,8 @@ impl Executor {
         })
     }
     /// notify the executor a computation is necessary
-    pub fn start(&self) -> Result<()> {
-        self.task_sender.try_send(())?;
+    pub fn start(&self, task: Task) -> Result<()> {
+        self.task_sender.try_send(task)?;
         Ok(())
     }
     pub fn die(self) -> Result<()> {

src/executor.rs

@@ -30,6 +30,8 @@ impl From<&CommandOutputLine> for LineAnalysis {
                     } else if regex_is_match!("^failures:$", content) {
                         // this isn't very discriminant...
                         LineType::Title(Kind::Sum)
+                    } else if regex_is_match!("^note: run with `RUST_BACKTRACE=", content) {
+                        LineType::BacktraceSuggestion
                     } else {
                         LineType::Normal
                     }

src/line_analysis.rs

@@ -30,6 +30,9 @@ pub enum LineType {
     /// the line saying if a test was passed
     TestResult(bool),
 
+    /// a suggestion to try with backtrace
+    BacktraceSuggestion,
+
     /// any other line
     Normal,
 }

src/line_type.rs

@@ -10,6 +10,7 @@ use {
 pub struct Report {
     pub lines: Vec<Line>,
     pub stats: Stats,
+    pub suggest_backtrace: bool,
 }
 
 impl Report {
@@ -33,6 +34,7 @@ impl Report {
         let mut passed_tests = 0;
         let mut cur_err_kind = None; // the current kind among stderr lines
         let mut is_in_out_fail = false;
+        let mut suggest_backtrace = false;
         for cmd_line in cmd_lines {
             debug!("cmd_line={:?}", &cmd_line);
             let line_analysis = LineAnalysis::from(cmd_line);
@@ -95,6 +97,9 @@ impl Report {
                             cur_err_kind = None;
                             is_in_out_fail = false;
                         }
+                        (LineType::BacktraceSuggestion, _) => {
+                            suggest_backtrace = true;
+                        }
                         _ => {
                             // TODO add normal if not broken with blank line
                             warn!("unexpected line: {:#?}", &line);
@@ -133,6 +138,6 @@ impl Report {
         // have been read but not added (at start or end)
         let mut stats = Stats::from(&lines);
         stats.passed_tests = passed_tests;
-        Ok(Report { lines, stats })
+        Ok(Report { lines, stats, suggest_backtrace })
     }
 }

src/report.rs

@@ -32,6 +32,8 @@ pub struct AppState {
     computing: bool,
     /// whether the user wants wrapped lines
     pub wrap: bool,
+    /// whether the user wants backtraces
+    pub backtrace: bool,
     /// whether we should display only titles and locations
     summary: bool,
     reverse: bool,
@@ -62,6 +64,7 @@ impl AppState {
             computing: true,
             summary: mission.settings.summary,
             wrap: mission.settings.wrap,
+            backtrace: false,
             reverse: mission.settings.reverse,
             status_skin,
             scroll: 0,
@@ -79,6 +82,11 @@ impl AppState {
             self.scroll_to_bottom();
         }
     }
+    pub fn new_task(&self) -> Task {
+        Task {
+            backtrace: self.backtrace,
+        }
+    }
     pub fn take_lines(&mut self) -> Option<Vec<CommandOutputLine>> {
         self.lines.take()
     }
@@ -188,6 +196,9 @@ impl AppState {
         self.summary ^= true;
         self.try_scroll_to_last_top_item();
     }
+    pub fn toggle_backtrace(&mut self) {
+        self.backtrace ^= true;
+    }
     pub fn toggle_wrap_mode(&mut self) {
         self.wrap ^= true;
         if self.wrapped_report.is_some() {
@@ -222,20 +233,25 @@ impl AppState {
         self.draw(w)
     }
     fn draw_status(&self, w: &mut W, y: u16) -> Result<()> {
-        let status = if matches!(self.cmd_result, CommandResult::Report(_)) {
-            if self.wrap {
-                "hit *q* to quit, *s* to toggle summary mode, *w* to not wrap lines"
+        let mut parts = vec!["hit *q* to quit"];
+        if let CommandResult::Report(report) = &self.cmd_result {
+            if report.suggest_backtrace {
+                parts.push("*t* to toggle backtraces");
             } else {
-                "hit *q* to quit, *s* to toggle summary mode, *w* to wrap lines"
+                parts.push("*s* to toggle summary mode");
+                if self.wrap {
+                    parts.push("*w* to not wrap lines");
+                } else {
+                    parts.push("*w* to wrap lines");
+                }
             }
-        } else {
-            "hit *q* to quit"
-        };
+        }
+        let status = parts.join(", ");
         if self.height > 1 {
             goto(w, y)?;
             self.status_skin.write_composite_fill(
                 w,
-                Composite::from_inline(status),
+                Composite::from_inline(&status),
                 self.width.into(),
                 Alignment::Left,
             )?;
@@ -301,7 +317,7 @@ impl AppState {
         let width = self.width as usize;
         let mut area = Area::new(0, y, self.width, self.page_height() as u16);
         let content_height = self.content_height();
-        let scrollbar = area.scrollbar(self.scroll as i32, content_height as i32);
+        let scrollbar = area.scrollbar(self.scroll, content_height);
         if scrollbar.is_some() {
             area.width -= 1;
         }