presolve-compiler 0.1.0-alpha.8

The Presolve compiler toolchain for TypeScript web applications.
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

use std::path::Path;

use presolve_parser::{parse_file, ParsedFile};

/// The parsed source files that participate in one compiler invocation.
///
/// Files are stored in path order so every frontend consumer observes a
/// deterministic application input before module resolution is introduced.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct CompilationUnit {
    files: Vec<ParsedFile>,
}

impl CompilationUnit {
    #[must_use]
    pub fn from_parsed_files(mut files: Vec<ParsedFile>) -> Self {
        files.sort_by(|left, right| left.path.cmp(&right.path));
        Self { files }
    }

    #[must_use]
    pub fn parse_sources<I, P, S>(sources: I) -> Self
    where
        I: IntoIterator<Item = (P, S)>,
        P: AsRef<Path>,
        S: AsRef<str>,
    {
        let files = sources
            .into_iter()
            .map(|(path, source)| parse_file(path, source.as_ref()))
            .collect();

        Self::from_parsed_files(files)
    }

    #[must_use]
    pub fn files(&self) -> &[ParsedFile] {
        &self.files
    }

    #[must_use]
    pub fn is_empty(&self) -> bool {
        self.files.is_empty()
    }
}

#[cfg(test)]
mod tests {
    use super::CompilationUnit;

    #[test]
    fn sorts_parsed_sources_by_path() {
        let unit = CompilationUnit::parse_sources([
            ("src/Zeta.tsx", "class Zeta {}"),
            ("src/Alpha.tsx", "class Alpha {}"),
        ]);

        let paths = unit
            .files()
            .iter()
            .map(|file| file.path.to_string_lossy().into_owned())
            .collect::<Vec<_>>();

        assert_eq!(paths, vec!["src/Alpha.tsx", "src/Zeta.tsx"]);
    }
}