[bndbuild] Improve behavior of --watch when target is phony

Author: Krusty/Benediction

Readme.mkd

@@ -5,6 +5,7 @@
 
  Several demos have been released using this toolchain. However they may not build with the very last version due to its evolution.
 
+ - 4deKades (2025) <https://www.pouet.net/prod.php?which=103970>, <https://github.com/rgiot/demo.revision2025.4deKades>
  -  J'AI PÉ-TÉLÉCRAN (2024) <https://www.pouet.net/prod.php?which=96575>, <https://github.com/rgiot/demo.revision2024.etchy>
  -  Come Join Us (2024) <https://www.pouet.net/prod.php?which=96537>
  -  Can Robots Take Control? (2021) <https://www.pouet.net/prod.php?which=88554>

cpclib-bndbuild/src/app.rs

@@ -3,6 +3,7 @@ use std::ops::Deref;
 use std::process::{Command, Stdio};
 use std::str::FromStr;
 use std::sync::Arc;
+use std::time::{Duration, Instant};
 
 use anyhow::Context;
 use camino::{Utf8Path, Utf8PathBuf};
@@ -40,6 +41,34 @@ pub struct BndBuilderApp {
     observers: Arc<ListOfBndBuilderObserverRc>
 }
 
+#[derive(Debug, Clone)]
+pub enum WatchState {
+    NoWatch,
+    WatchFirstRound,
+    WatchNextRounds{last_build: Instant},
+}
+
+impl WatchState {
+    pub fn request_watch(&self) -> bool {
+        !matches!(self, WatchState::NoWatch)
+    }
+
+    pub fn disable_phony(&self) -> bool {
+        match self {
+            Self::NoWatch => false,
+            Self::WatchFirstRound => false,
+            Self::WatchNextRounds{..} => true
+        }
+    }
+
+    pub fn last_build(&self) -> Option<&Instant> {
+        match self {
+            Self::WatchNextRounds{last_build} => Some(last_build),
+            _ => None
+        }
+    }
+}
+
 #[derive(Debug)]
 pub enum BndBuilderCommandInner {
     /// Print the help of the given command
@@ -68,7 +97,7 @@ pub enum BndBuilderCommandInner {
     /// Build the corresponding targets
     Build {
         targets: Option<Vec<Utf8PathBuf>>,
-        watch: bool,
+        watch: WatchState,
         current_step: usize,
         builder: BndBuilder
     },
@@ -202,11 +231,12 @@ impl BndBuilderCommand {
     /// TODO wire parallal execution
     fn execute_build(
         init_targets: Option<Vec<Utf8PathBuf>>,
-        watch: bool,
+        watch: WatchState,
         mut current_step: usize,
         builder: BndBuilder,
         observers: Arc<ListOfBndBuilderObserverRc>
     ) -> Result<Option<Self>, BndBuilderError> {
+
         let targets_provided = init_targets.is_some();
 
         // get the list of targets
@@ -227,7 +257,7 @@ impl BndBuilderCommand {
         let tgt = &targets[current_step];
 
         // execute if needed
-        if builder.outdated(tgt)? {
+        let last_build = if builder.outdated(&watch, tgt)? {
             builder.execute(tgt).map_err(|e| {
                 if targets_provided {
                     e
@@ -238,7 +268,10 @@ impl BndBuilderCommand {
                     }
                 }
             })?;
-        }
+            Some(Instant::now())
+        } else {
+            None
+        };
 
         // set up the next step if any
         let over = init_targets.as_ref().map(|v| v.len() - 1).unwrap_or(0) == current_step;
@@ -250,14 +283,15 @@ impl BndBuilderCommand {
             current_step += 1;
         }
 
-        if over && !watch {
+        if over && !watch.request_watch() {
             Ok(None)
         }
         else {
+            std::thread::sleep(Duration::from_millis(2000)); // duration to wait
             Ok(Some(BndBuilderCommand {
                 inner: BndBuilderCommandInner::Build {
                     targets: init_targets,
-                    watch,
+                    watch: WatchState::WatchNextRounds{last_build: last_build.unwrap_or_else(|| watch.last_build().cloned().unwrap())},
                     current_step,
                     builder
                 },
@@ -834,7 +868,7 @@ impl BndBuilderApp {
 
                 Ok(BndBuilderCommandInner::Build {
                     targets,
-                    watch: watch_requested,
+                    watch: if watch_requested {WatchState::WatchFirstRound} else {WatchState::NoWatch},
                     current_step: 0,
                     builder
                 })

cpclib-bndbuild/src/builder.rs

@@ -8,6 +8,7 @@ use cpclib_common::camino::{Utf8Path, Utf8PathBuf};
 use cpclib_common::itertools::Itertools;
 use minijinja::{Environment, Error, ErrorKind, context};
 
+use crate::app::WatchState;
 use crate::BndBuilderError;
 use crate::event::{
     BndBuilderObserved, BndBuilderObserver, BndBuilderObserverRc, ListOfBndBuilderObserverRc,
@@ -287,7 +288,7 @@ impl BndBuilder {
                 return Err(BndBuilderError::DisabledTarget(p.to_string()));
             }
 
-            let done = rule.is_up_to_date(Some(p));
+            let done = rule.is_up_to_date(None, Some(p));
             if done {
                 self.emit_stdout(&format!("Rule {p} already exists\n"));
                 // nothing to do
@@ -322,8 +323,8 @@ impl BndBuilder {
 
 impl BndBuilder {
     #[inline]
-    pub fn outdated<P: AsRef<Utf8Path>>(&self, target: P) -> Result<bool, BndBuilderError> {
-        self.inner.borrow_dependent().outdated(target, true)
+    pub fn outdated<P: AsRef<Utf8Path>>(&self, watch: &WatchState, target: P) -> Result<bool, BndBuilderError> {
+        self.inner.borrow_dependent().outdated(target, watch,true)
     }
 
     #[inline]

cpclib-bndbuild/src/rules/graph.rs

@@ -1,12 +1,13 @@
-use std::collections::{BTreeMap, HashSet};
+use std::{collections::{BTreeMap, HashSet}, time::{Instant, SystemTime}};
 
 use camino::Utf8PathBuf;
+use cpclib_asm::file;
 use cpclib_common::camino::Utf8Path;
 use cpclib_common::itertools::Itertools;
 use topologic::AcyclicDependencyGraph;
 
 use super::{Rule, Rules};
-use crate::BndBuilderError;
+use crate::{app::WatchState, BndBuilderError};
 
 #[derive(Clone)]
 pub struct Graph<'r> {
@@ -62,11 +63,14 @@ impl<'r> Graph<'r> {
     pub fn outdated<P: AsRef<Utf8Path>>(
         &self,
         p: P,
+        watch: &WatchState,
         skip_rules_without_commands: bool
     ) -> Result<bool, BndBuilderError> {
+
+
         let p = p.as_ref();
         // a phony rule is always outdated
-        if self.rule(p)?.is_phony() {
+        if !watch.disable_phony() && self.rule(p)?.is_phony() {
             return Ok(true);
         }
 
@@ -77,15 +81,19 @@ impl<'r> Graph<'r> {
             let res = match self.rule(p) {
                 Ok(r) => {
                     if skip_rules_without_commands {
-                        if r.is_phony() {
-                            false
+                        if  r.is_phony() {
+                            match watch {
+                                WatchState::NoWatch => false,
+                                WatchState::WatchFirstRound => { false  }, 
+                                WatchState::WatchNextRounds { last_build } => { false  }
+                            }
                         }
                         else {
-                            !r.is_up_to_date::<Utf8PathBuf>(None)
+                            !r.is_up_to_date::<Utf8PathBuf>(watch.last_build().cloned(), None)
                         }
                     }
                     else {
-                        !r.is_up_to_date::<Utf8PathBuf>(None)
+                        !r.is_up_to_date::<Utf8PathBuf>(watch.last_build().cloned(),None)
                     }
                 },
 
@@ -94,7 +102,14 @@ impl<'r> Graph<'r> {
                         return Err(BndBuilderError::UnknownTarget(msg));
                     }
                     else {
-                        false
+                        if let Some(last_build) = watch.last_build() {
+                            let file_modification= p.metadata().unwrap().modified().unwrap();
+                            let file_modification = file_modification.elapsed().unwrap();
+                            let last_build = last_build.elapsed();
+                            last_build > file_modification
+                        } else {
+                            false
+                        }
                     }
                 },
                 _ => todo!()

cpclib-bndbuild/src/rules/rule.rs

@@ -1,4 +1,5 @@
 use std::fmt::Display;
+use std::time::Instant;
 
 use cpclib_common::camino::{Utf8Path, Utf8PathBuf};
 use cpclib_common::itertools::Itertools;
@@ -286,10 +287,10 @@ impl Rule {
         }
     }
 
-    pub fn is_up_to_date<P: AsRef<Utf8Path>>(&self, for_target: Option<P>) -> bool {
+    pub fn is_up_to_date<P: AsRef<Utf8Path>>(&self, last_build: Option<Instant>, for_target: Option<P>) -> bool {
 
         // phony rules are never up to date
-        if self.is_phony() {
+        if self.is_phony() && last_build.is_none() {
             return false;
         }