feat(cache): directories keep their times too; FLOW_HEADS only without OXY_BUILD (refs #52) de1d7926185f

    // The heads name the build only when OXY_BUILD does not: a CI job that

    // sets it stays fresh from one state to the next (oxygenflow#52).

    if !std::env::var("OXY_BUILD").is_ok_and(|b| !b.trim().is_empty()) {

        println!("cargo:rerun-if-env-changed=FLOW_HEADS");

    }

                note(

                    &mut sink,

                    format!(

                        "cache: {restored} of {} files and directories unchanged since the cached build, their times kept",

                        sources.len()

                    ),

                );

    // Directories too, after their files (#52): a build script's

    // `rerun-if-changed` on a directory looks at its time as well. A

    // directory whose listing is unchanged gets its old time back; one that

    // gained or lost an entry keeps its checkout's, so the change shows.

    restore_dir_times(dir, Path::new(""), before, &mut out, &mut restored);

/// The key a directory's entry has in the sources: its path and a slash.

fn dir_key(rel: &Path) -> String {

    format!("{}/", rel.display())

}

fn restore_dir_times(

    root: &Path,

    rel: &Path,

    before: Option<&crate::cache::Sources>,

    out: &mut crate::cache::Sources,

    restored: &mut usize,

) {

    let here = root.join(rel);

    let Ok(entries) = std::fs::read_dir(&here) else { return };

    let mut names: Vec<(String, bool)> = Vec::new();

    for e in entries.flatten() {

        let is_dir = e.file_type().is_ok_and(|t| t.is_dir());

        names.push((e.file_name().to_string_lossy().into_owned(), is_dir));

    }

    names.sort();

    for (name, is_dir) in &names {

        if *is_dir {

            restore_dir_times(root, &rel.join(name), before, out, restored);

        }

    }

    let mut h = blake3::Hasher::new();

    for (name, is_dir) in &names {

        h.update(name.as_bytes());

        h.update(if *is_dir { b"/\n".as_slice() } else { b"\n".as_slice() });

    }

    let hex = h.finalize().to_hex().to_string();

    let key = dir_key(rel);

    let kept = before.and_then(|b| b.get(&key)).filter(|(h, _)| *h == hex).map(|(_, t)| *t);

    let t = match kept {

        Some(t) => {

            let at = std::time::UNIX_EPOCH + std::time::Duration::from_secs(t.max(0) as u64);

            if std::fs::File::open(&here).and_then(|f| f.set_modified(at)).is_err() {

                return;

            }

            *restored += 1;

            t

        }

        None => std::fs::metadata(&here)

            .ok()

            .and_then(|m| m.modified().ok())

            .and_then(|m| m.duration_since(std::time::UNIX_EPOCH).ok())

            .map(|d| d.as_secs() as i64)

            .unwrap_or(0),

    };

    out.insert(key, (hex, t));

}

        // Without a cached build nothing moves, and the sources are listed:

        // three files and the directory holding them.

        assert_eq!((restored, again.len()), (0, 4));

        assert!(again.contains_key("/"));

        // A directory whose listing is unchanged gets its time back; one

        // that gained an entry keeps its new time, so a build script's

        // `rerun-if-changed` on it sees the change.

        std::fs::create_dir(dir.path().join("migrations")).unwrap();

        std::fs::write(dir.path().join("migrations/0001.sql"), "x").unwrap();

        let mut files = files;

        files.push(("migrations/0001.sql".into(), h("x")));

        let (mut kept, _) = restore_times(dir.path(), &files, None);

        kept.get_mut("migrations/").unwrap().1 = 2_000_000;

        kept.get_mut("migrations/0001.sql").unwrap().1 = 2_000_000;

        let (_, restored) = restore_times(dir.path(), &files, Some(&kept));

        assert_eq!(secs(&dir.path().join("migrations")), 2_000_000, "unchanged listing: its old time");

        assert!(restored >= 2);

        std::fs::write(dir.path().join("migrations/0002.sql"), "y").unwrap();

        files.push(("migrations/0002.sql".into(), h("y")));

        let (now_sources, _) = restore_times(dir.path(), &files, Some(&kept));

        assert!(secs(&dir.path().join("migrations")) > 2_000_000, "a new entry: it looks changed");

        assert_ne!(now_sources["migrations/"].0, kept["migrations/"].0);

  path crate look changed. Directories are kept the same way, by their

  listing (the names in them): an unchanged one gets its old time back,

  one that gained or lost an entry keeps its new time, so a build

  script's `rerun-if-changed` on a directory sees exactly what changed.

  The log says how many files and directories kept their times. A build

  script that reads a per-state value (the Oxygen crates' `FLOW_HEADS`)

  reruns on every state; those crates read it only when `OXY_BUILD` is

  unset, so a pipeline that sets `OXY_BUILD` keeps them fresh.