typstyle 0.14.4

The CLI for Typstyle.
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
124
125
126
127
128
129
130

use std::{
    collections::HashMap,
    ffi::OsStr,
    fs,
    path::{Path, PathBuf},
    process::Command,
    time::SystemTime,
};

use insta_cmd::get_cargo_bin;
use tempfile::TempDir;

pub const INSTA_FILTERS: &[(&str, &str)] = &[
    (r"(?m)^(.+) in [\w.]+$", "$1 in [DURATION]"),
    (
        r"(\b[A-Z]:)?[\\/].*?[\\/]\.typstyle-tests---[^\\/]+[\\/]",
        "[TEMP_PATH]/",
    ),
    (r"\\\\?([\w\d.])", "/$1"),
    (r"typstyle.exe", "typstyle"),
];

pub struct Workspace {
    #[allow(unused)]
    tempdir: TempDir,
    project_dir: PathBuf,
    /// Records file last modified time.
    tracked: HashMap<PathBuf, SystemTime>,
}

#[allow(dead_code)]
impl Workspace {
    pub fn new() -> Workspace {
        let tempdir = marked_tempdir();
        let project_dir = tempdir.path().join("project");
        fs::create_dir_all(&project_dir).unwrap();
        Workspace {
            tempdir,
            project_dir,
            tracked: Default::default(),
        }
    }

    pub fn project_path(&self) -> &Path {
        &self.project_dir
    }

    pub fn cmd(&self, cmd: impl AsRef<OsStr>) -> Command {
        let mut rv = Command::new(cmd);
        rv.current_dir(self.project_path());
        rv
    }

    pub fn cli(&self) -> Command {
        self.cmd(get_cargo_bin("typstyle"))
    }

    pub fn write(&self, path: impl AsRef<Path>, contents: impl AsRef<[u8]>) {
        self.write_impl(path.as_ref(), contents.as_ref());
    }

    /// Write file to project and track its modified time.
    pub fn write_tracked(&mut self, path: impl AsRef<Path>, contents: impl AsRef<[u8]>) {
        let p = self.write_impl(path.as_ref(), contents.as_ref());
        if let Ok(time) = p.metadata().unwrap().modified() {
            self.tracked.insert(p, time);
        }
    }

    fn write_impl(&self, path: &Path, contents: &[u8]) -> PathBuf {
        let p = self.project_path().join(path);
        fs::create_dir_all(p.parent().unwrap()).ok();
        fs::write(&p, contents).unwrap();
        p
    }

    pub fn read_string(&self, path: impl AsRef<Path>) -> String {
        let p = self.project_path().join(path.as_ref());
        fs::read_to_string(p).unwrap()
    }

    pub fn is_modified(&self, path: impl AsRef<Path>) -> bool {
        !self.is_unmodified(path)
    }

    pub fn is_unmodified(&self, path: impl AsRef<Path>) -> bool {
        let p = self.project_path().join(path.as_ref());
        if let Ok(time) = p.metadata().unwrap().modified() {
            self.tracked
                .get(&p)
                .is_some_and(|old_time| *old_time == time)
        } else {
            true
        }
    }

    pub fn all_unmodified(&self) -> bool {
        self.tracked
            .iter()
            .all(|(p, old_time)| match p.metadata().unwrap().modified() {
                Ok(time) => *old_time == time,
                Err(_) => true,
            })
    }
}

impl Default for Workspace {
    fn default() -> Self {
        Self::new()
    }
}

fn marked_tempdir() -> TempDir {
    TempDir::with_prefix(".typstyle-tests---").unwrap()
}

#[allow(unused)]
macro_rules! typstyle_cmd_snapshot {
    ($cmd:expr, @$snapshot:literal) => {
        let mut settings = insta::Settings::clone_current();
        for (matcher, replacement) in $crate::common::INSTA_FILTERS {
            settings.add_filter(matcher, *replacement);
        }
        let _guard = settings.bind_to_scope();
        insta_cmd::assert_cmd_snapshot!($cmd, @$snapshot);
    };
}

#[allow(unused_imports)]
pub(crate) use typstyle_cmd_snapshot;