geam 0.1.1

Experimental Rust-embedded execution runtime for typed Gleam programs
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

use camino::Utf8PathBuf;
use ecow::EcoString;

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ModuleSource {
    module: EcoString,
    path: Utf8PathBuf,
    source: String,
}

impl ModuleSource {
    pub fn new(
        module: impl Into<EcoString>,
        path: impl Into<Utf8PathBuf>,
        source: impl Into<String>,
    ) -> Self {
        Self {
            module: module.into(),
            path: path.into(),
            source: source.into(),
        }
    }

    pub fn module(&self) -> &EcoString {
        &self.module
    }

    pub fn path(&self) -> &Utf8PathBuf {
        &self.path
    }

    pub fn source(&self) -> &str {
        &self.source
    }

    pub(super) fn into_parts(self) -> (EcoString, Utf8PathBuf, String) {
        (self.module, self.path, self.source)
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PackageSource {
    package: EcoString,
    direct_dependencies: Box<[EcoString]>,
    modules: Box<[ModuleSource]>,
}

impl PackageSource {
    pub fn new<Dependency>(
        package: impl Into<EcoString>,
        direct_dependencies: impl IntoIterator<Item = Dependency>,
        modules: impl IntoIterator<Item = ModuleSource>,
    ) -> Self
    where
        Dependency: Into<EcoString>,
    {
        Self {
            package: package.into(),
            direct_dependencies: direct_dependencies.into_iter().map(Into::into).collect(),
            modules: modules.into_iter().collect(),
        }
    }

    pub fn package(&self) -> &EcoString {
        &self.package
    }

    pub fn direct_dependencies(&self) -> &[EcoString] {
        &self.direct_dependencies
    }

    pub fn modules(&self) -> &[ModuleSource] {
        &self.modules
    }

    pub(super) fn into_parts(self) -> (EcoString, Box<[EcoString]>, Box<[ModuleSource]>) {
        (self.package, self.direct_dependencies, self.modules)
    }
}

#[cfg(test)]
mod tests {
    use super::{ModuleSource, PackageSource};

    #[test]
    fn module_source_exposes_owned_source_parts() {
        let source = ModuleSource::new("main", "src/main.gleam", "pub fn main() { 1 }");

        assert_eq!(source.module(), "main");
        assert_eq!(source.path().as_str(), "src/main.gleam");
        assert_eq!(source.source(), "pub fn main() { 1 }");
    }

    #[test]
    fn package_source_exposes_package_dependencies_and_modules() {
        let source = PackageSource::new(
            "application",
            ["library"],
            [ModuleSource::new(
                "main",
                "src/main.gleam",
                "pub fn main() { 1 }",
            )],
        );

        assert_eq!(source.package(), "application");
        assert_eq!(source.direct_dependencies(), ["library"]);
        assert_eq!(source.modules().len(), 1);
        assert_eq!(source.modules()[0].module(), "main");
    }
}