sora-export 0.1.1

Simple and powerful configuration table compiler for games and data-heavy tools.
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

use std::collections::BTreeMap;

use crate::{
    binary::BinaryBundleExporter, cbor::CborBundleExporter, debug_json::DebugJsonExporter,
    exporter::DataExporter, json::JsonBundleExporter, protobuf::ProtobufBundleExporter,
    typed_protobuf::TypedProtobufExporter,
};

#[derive(Default)]
pub struct ExporterRegistry {
    exporters: BTreeMap<String, Box<dyn DataExporter>>,
}

impl ExporterRegistry {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn with_builtin_exporters() -> Self {
        let mut registry = Self::new();
        registry.register(BinaryBundleExporter);
        registry.register(CborBundleExporter);
        registry.register(DebugJsonExporter);
        registry.register(JsonBundleExporter);
        registry.register(ProtobufBundleExporter);
        registry.register(TypedProtobufExporter);
        registry
    }

    pub fn register<E: DataExporter + 'static>(&mut self, exporter: E) {
        self.exporters
            .insert(exporter.format_name().to_owned(), Box::new(exporter));
    }

    pub fn get(&self, format_name: &str) -> Option<&dyn DataExporter> {
        self.exporters.get(format_name).map(Box::as_ref)
    }

    pub fn supported_formats(&self) -> Vec<&'static str> {
        self.exporters
            .values()
            .map(|exporter| exporter.format_name())
            .collect()
    }
}

pub fn builtin_supported_formats() -> Vec<&'static str> {
    ExporterRegistry::with_builtin_exporters().supported_formats()
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::exporter::OutputKind;

    #[test]
    fn registry_finds_builtin_exporters() {
        let registry = ExporterRegistry::with_builtin_exporters();

        assert_eq!(
            registry.get("binary").unwrap().output_kind(),
            OutputKind::File
        );
        assert_eq!(
            registry.get("json-debug").unwrap().output_kind(),
            OutputKind::Directory
        );
        assert_eq!(
            registry.get("json").unwrap().output_kind(),
            OutputKind::File
        );
        assert_eq!(
            registry.get("cbor").unwrap().output_kind(),
            OutputKind::File
        );
        assert_eq!(
            registry.get("sora-protobuf").unwrap().output_kind(),
            OutputKind::File
        );
        assert_eq!(
            registry.get("proto").unwrap().output_kind(),
            OutputKind::File
        );
        assert!(registry.get("unknown").is_none());
        assert_eq!(
            registry.supported_formats(),
            vec![
                "binary",
                "cbor",
                "json",
                "json-debug",
                "proto",
                "sora-protobuf"
            ]
        );
    }
}