waterui-cli 0.1.4

Cross-platform tooling for WaterUI applications
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

//! Stable fingerprints for preview build inputs.

use std::fmt;
use std::path::Path;

use color_eyre::eyre::{Context as _, Result, bail};
use sha2::{Digest as _, Sha256};
use walkdir::WalkDir;

use crate::runtime_compat::{is_preview_build_input_file, should_skip_scan_dir};

/// Stable content fingerprint for all inputs that can affect a preview build.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(super) struct ProjectInputsFingerprint([u8; 32]);

impl fmt::Display for ProjectInputsFingerprint {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(&hex::encode(self.0))
    }
}

/// Fingerprint the current preview build inputs without blocking the async executor.
pub(super) async fn project_inputs_fingerprint(
    project_path: &Path,
) -> Result<ProjectInputsFingerprint> {
    let project_path = project_path.to_path_buf();
    smol::unblock(move || scan_project_inputs(&project_path))
        .await
        .wrap_err("failed to fingerprint preview build inputs")
}

fn scan_project_inputs(project_path: &Path) -> Result<ProjectInputsFingerprint> {
    if !project_path.is_dir() {
        bail!(
            "preview project directory does not exist: {}",
            project_path.display()
        );
    }

    let mut hasher = Sha256::new();
    let entries = WalkDir::new(project_path)
        .follow_links(true)
        .sort_by_file_name()
        .into_iter()
        .filter_entry(|entry| {
            entry.depth() == 0
                || !entry.file_type().is_dir()
                || !should_skip_scan_dir(entry.file_name())
        });

    for entry in entries {
        let entry = entry?;
        if entry.file_type().is_dir() || !is_preview_build_input_file(entry.path()) {
            continue;
        }
        if !entry.file_type().is_file() {
            continue;
        }

        let relative = entry.path().strip_prefix(project_path).wrap_err_with(|| {
            format!(
                "preview input {} is outside project root {}",
                entry.path().display(),
                project_path.display()
            )
        })?;
        let relative = relative.to_str().ok_or_else(|| {
            color_eyre::eyre::eyre!(
                "preview build input path is not valid UTF-8: {}",
                relative.display()
            )
        })?;
        hasher.update(relative.as_bytes());
        hasher.update([0]);
        let contents = std::fs::read(entry.path())?;
        hasher.update(contents.len().to_le_bytes());
        hasher.update(contents);
    }

    Ok(ProjectInputsFingerprint(hasher.finalize().into()))
}

#[cfg(test)]
mod tests {
    use std::fs;

    use tempfile::tempdir;

    use super::*;

    #[test]
    fn fingerprint_tracks_inputs_and_ignores_preview_outputs() {
        let dir = tempdir().unwrap();
        let src = dir.path().join("src");
        fs::create_dir_all(&src).unwrap();
        let source = src.join("lib.rs");
        fs::write(&source, "fn first() {}").unwrap();

        let original = scan_project_inputs(dir.path()).unwrap();

        fs::write(dir.path().join("preview.png"), "render output").unwrap();
        assert_eq!(scan_project_inputs(dir.path()).unwrap(), original);

        fs::write(&source, "fn other() {}").unwrap();
        assert_ne!(scan_project_inputs(dir.path()).unwrap(), original);
    }

    #[cfg(unix)]
    #[test]
    fn fingerprint_tracks_symlinked_source_directories() {
        use std::os::unix::fs::symlink;

        let project = tempdir().unwrap();
        let sources = tempdir().unwrap();
        let source = sources.path().join("lib.rs");
        fs::write(&source, "fn first() {}").unwrap();
        symlink(sources.path(), project.path().join("src")).unwrap();

        let original = scan_project_inputs(project.path()).unwrap();
        fs::write(&source, "fn other() {}").unwrap();
        assert_ne!(scan_project_inputs(project.path()).unwrap(), original);
    }
}