facet_generate 0.16.0

Generate Swift, Kotlin and TypeScript from types annotated with `#[derive(Facet)]`
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

use std::{
    fmt::{self, Display, Formatter},
    fs,
    path::{Path, PathBuf},
};

use expect_test::ExpectFile;
use ignore::WalkBuilder;

/// Target languages included in snapshot integration tests. Used to loop over languages
/// in a single test, dispatching to the appropriate installer for each.
pub enum TargetLanguage {
    #[deprecated(
        since = "0.16.0",
        note = "The Java generator is deprecated. Use Kotlin instead."
    )]
    Java,
    Kotlin,
    Swift,
    TypeScript,
}

#[expect(
    deprecated,
    reason = "Display must handle all variants including deprecated TargetLanguage::Java"
)]
impl Display for TargetLanguage {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            TargetLanguage::Java => write!(f, "Java"),
            TargetLanguage::Kotlin => write!(f, "Kotlin"),
            TargetLanguage::Swift => write!(f, "Swift"),
            TargetLanguage::TypeScript => write!(f, "TypeScript"),
        }
    }
}

#[expect(
    deprecated,
    reason = "snapshot tests cover the deprecated Java generator"
)]
mod basic;
mod with_bytes;
#[expect(
    deprecated,
    reason = "snapshot tests cover the deprecated Java generator"
)]
mod with_namespaces_as_external;
#[expect(
    deprecated,
    reason = "snapshot tests cover the deprecated Java generator"
)]
mod with_namespaces_as_internal;
#[expect(
    deprecated,
    reason = "snapshot tests cover the deprecated Java generator"
)]
mod with_serialization;
#[expect(
    deprecated,
    reason = "snapshot tests cover the deprecated Java generator"
)]
mod with_serialization_and_namespaces_as_external;
#[expect(
    deprecated,
    reason = "snapshot tests cover the deprecated Java generator"
)]
mod with_serialization_and_serde_external;
#[expect(
    deprecated,
    reason = "snapshot tests cover the deprecated Java generator"
)]
mod with_serialization_and_serde_internal;
#[expect(
    deprecated,
    reason = "snapshot tests cover the deprecated Java generator"
)]
mod with_serialization_and_serde_local;

fn read_files_and_create_expect_dirs(
    tmp_path: impl AsRef<Path>,
    out_dir: impl AsRef<Path>,
) -> Vec<(String, PathBuf)> {
    let mut files = Vec::new();
    for entry in WalkBuilder::new(&tmp_path)
        .hidden(false)
        .follow_links(true)
        .build()
    {
        if let Ok(entry) = entry
            && let Some(file_type) = entry.file_type()
            && file_type.is_file()
        {
            let relative_path = entry.path().strip_prefix(&tmp_path).unwrap();
            let expected = out_dir.as_ref().join(relative_path);

            fs::create_dir_all(expected.parent().unwrap()).unwrap();

            let actual = fs::read_to_string(entry.path()).unwrap();

            files.push((actual, expected));
        }
    }
    files
}

fn check(actual: &str, expect: &ExpectFile) {
    expect.assert_eq(actual);
}