watchso 0.1.0

Hot reload Solana programs
Documentation 
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

//! Custom `glob` implementation.

use std::path::{Path, PathBuf};

use async_recursion::async_recursion;
use globset::{GlobBuilder, GlobSet, GlobSetBuilder};
use miette::IntoDiagnostic;
use tokio::fs::{self, DirEntry};

/// Custom `glob` implementation to filter through pathnames in a directory.
///
/// Returns all the matching paths based on the given `path` and included/excluded globs.
pub async fn glob<P, I, E>(
    path: P,
    include_globs: I,
    exclude_globs: E,
    literal_seperator: bool,
) -> miette::Result<Vec<PathBuf>>
where
    P: AsRef<Path> + Send + Sync,
    I: IntoIterator<Item = String>,
    E: IntoIterator<Item = String>,
{
    let include_globset = create_globset(include_globs, literal_seperator)?;
    let exclude_globset = create_globset(exclude_globs, literal_seperator)?;

    let mut matches = vec![];
    recursively_read_dir_mut(&path, &mut |entry| {
        let is_match = entry
            .path()
            .strip_prefix(&path)
            .ok()
            .and_then(|relative_path| relative_path.to_str())
            .map(|s| include_globset.is_match(s) && !exclude_globset.is_match(s))
            .unwrap_or(false);

        if is_match {
            matches.push(entry.path());
        }
    })
    .await;

    Ok(matches)
}

/// Create a [`GlobSet`] from the given `globs`.
fn create_globset<G: IntoIterator<Item = String>>(
    globs: G,
    literal_seperator: bool,
) -> miette::Result<GlobSet> {
    let mut globset_builder = GlobSetBuilder::new();
    for glob in globs {
        globset_builder.add(
            GlobBuilder::new(&glob)
                .literal_separator(literal_seperator)
                .build()
                .into_diagnostic()?,
        );
    }

    globset_builder.build().into_diagnostic()
}

/// Recursively read the given directory with mutable borrowed callback on each entry.
#[async_recursion]
async fn recursively_read_dir_mut<P, F>(path: &P, cb: &mut F)
where
    P: AsRef<Path> + Send + Sync,
    F: FnMut(DirEntry) + Send + Sync,
{
    if let Ok(mut read_dir) = fs::read_dir(path).await {
        while let Ok(Some(entry)) = read_dir.next_entry().await {
            if let Ok(metadata) = entry.metadata().await {
                if metadata.is_dir() {
                    recursively_read_dir_mut(&path.as_ref().join(entry.file_name()), cb).await;
                }

                cb(entry);
            }
        }
    }
}