flutter_rust_bridge_codegen 2.0.0-dev.0

High-level memory-safe binding generator for Flutter/Dart <-> Rust
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
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

use anyhow::{Context, Result};
use std::path::{Path, PathBuf};

pub(crate) fn glob_path(pattern: &Path) -> Result<Vec<PathBuf>> {
    let pattern = normalize_windows_unc_path(pattern.to_str().context("cannot convert to str")?);
    glob::glob(pattern)?
        .filter_map(Result::ok)
        .map(|p| canonicalize_with_error_message(&p))
        .collect::<Result<Vec<_>>>()
}

pub(crate) fn path_to_string(path: &Path) -> Result<String> {
    Ok(path
        .to_str()
        .context("cannot convert path to str")?
        .to_owned())
}

pub(crate) fn find_parent_dir_with_file(
    path_start: &Path,
    probe_file_name: &str,
) -> Option<PathBuf> {
    let mut path = path_start.to_owned();
    loop {
        if path.join(probe_file_name).is_file() {
            return Some(path);
        }
        if !path.pop() {
            break;
        }
    }
    None
}

pub(crate) fn find_dart_package_dir(dart_file_path: &Path) -> Result<PathBuf> {
    find_parent_dir_with_file(dart_file_path, "pubspec.yaml").with_context(|| {
        format!("Fail to detect dart package from dart_file_path={dart_file_path:?}")
    })
}

pub(crate) fn find_rust_crate_dir(rust_file_path: &Path) -> Result<PathBuf> {
    find_parent_dir_with_file(rust_file_path, "Cargo.toml").with_context(|| {
        format!("Fail to detect rust crate dir from rust_file_path={rust_file_path:?}")
    })
}

pub(crate) fn normalize_windows_unc_path(path: &str) -> &str {
    // on windows get rid of the UNC path
    path.strip_prefix(r"\\?\").unwrap_or(path)
}

pub(crate) fn canonicalize_with_error_message(path: &Path) -> Result<PathBuf> {
    path.canonicalize()
        .with_context(|| format!("path={path:?}"))
}

#[cfg(test)]
mod tests {
    use crate::utils::path_utils::glob_path;
    use anyhow::Result;
    use std::collections::HashSet;
    use std::fs;
    use std::path::PathBuf;
    use tempfile::tempdir;

    #[test]
    fn test_glob_path_simple() -> Result<()> {
        let temp_dir = tempdir()?;
        fs::write(temp_dir.path().join("apple.rs"), "")?;
        fs::write(temp_dir.path().join("orange.rs"), "")?;
        fs::write(temp_dir.path().join("aha.rs"), "")?;

        fn extract_names(items: &[PathBuf]) -> HashSet<String> {
            items
                .iter()
                .map(|x| x.file_name().unwrap().to_str().unwrap().to_owned())
                .collect()
        }

        assert_eq!(
            PathBuf::from("/a/b").join("*.rs"),
            PathBuf::from("/a/b/*.rs")
        );
        assert_eq!(
            PathBuf::from("/a/b").join("c/*.rs"),
            PathBuf::from("/a/b/c/*.rs")
        );
        assert_eq!(
            PathBuf::from("/a/b").join("/c/*.rs"),
            PathBuf::from("/c/*.rs")
        );

        assert_eq!(
            extract_names(&glob_path(&temp_dir.path().join("*.rs"))?),
            vec![
                "apple.rs".to_owned(),
                "orange.rs".to_owned(),
                "aha.rs".to_owned()
            ]
            .into_iter()
            .collect(),
        );

        assert_eq!(
            extract_names(&glob_path(&temp_dir.path().join("a*.rs"))?),
            vec!["apple.rs".to_owned(), "aha.rs".to_owned()]
                .into_iter()
                .collect(),
        );

        Ok(())
    }
}