uninode 0.4.4

Universal object type
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123

//
// Copyright (c) 2022 Oleg Lelenkov <o.lelenkov@gmail.com>
// Distributed under terms of the BSD 3-Clause license.
//

mod error;
#[cfg(feature = "toml")]
pub mod toml;
#[cfg(feature = "yaml")]
pub mod yaml;

pub use self::error::{UniNodeFmtError, UniNodeLoadError, UniNodeIoError};

use std::collections::HashMap;
use std::sync::RwLock;
use std::path::Path;

use once_cell::sync::Lazy;

use crate::value::UniNode;

type GlobalFormat = Box<dyn UniNodeFormat + Sync + Send + 'static>;
type FormatMap = HashMap<String, GlobalFormat>;

static FORMATS: Lazy<RwLock<FormatMap>> = Lazy::new(|| {
    let mut cont = FormatMap::new();
    #[cfg(feature = "yaml")]
    add_format(&mut cont, yaml::YamlFormat::default());
    #[cfg(feature = "toml")]
    add_format(&mut cont, toml::TomlFormat::default());
    RwLock::new(cont)
});

pub trait UniNodeFormat {
    fn extensions(&self) -> &[&str];

    fn parse(&self, text: &str) -> Result<UniNode, UniNodeFmtError>;

    fn build(&self, node: &UniNode) -> Result<String, UniNodeFmtError>;
}

fn add_format<L>(cont: &mut FormatMap, format: L)
where
    L: UniNodeFormat + Clone + Sync + Send + 'static,
{
    for ext in format.extensions() {
        cont.insert(ext.to_string(), Box::new(format.clone()));
    }
}

pub fn register_format<F>(format: F)
where
    F: UniNodeFormat + Clone + Sync + Send + 'static,
{
    let mut formats = FORMATS.write().unwrap();
    add_format(&mut formats, format);
}

pub fn available_extensions() -> Vec<String> {
    let formats = FORMATS.read().unwrap();
    formats.keys().cloned().collect()
}

impl UniNode {
    pub fn parse<P>(path: P, content: &str) -> Result<UniNode, UniNodeLoadError>
    where
        P: AsRef<Path>,
    {
        let path = path.as_ref();
        let ext = path
            .extension()
            .and_then(|e| e.to_str())
            .or_else(|| path.to_str())
            .ok_or_else(|| {
                let path = path.to_string_lossy();
                let err = UniNodeFmtError::NotDefinedFormat(path.into());
                UniNodeLoadError::Fmt(err)
            })?;

        let formats = FORMATS.read().unwrap();
        if !formats.contains_key(ext) {
            let err = UniNodeFmtError::NotDefinedFormat(ext.to_string());
            return Err(UniNodeLoadError::Fmt(err));
        }

        formats[ext].parse(content).map_err(UniNodeLoadError::Fmt)
    }

    pub fn load<P>(path: P) -> Result<UniNode, UniNodeLoadError>
    where
        P: AsRef<Path>,
    {
        let path = path.as_ref();
        match path.extension().and_then(|e| e.to_str()) {
            Some(ext) => {
                let formats = FORMATS.read().unwrap();
                if !formats.contains_key(ext) {
                    let err =
                        UniNodeFmtError::NotDefinedFormat(ext.to_string());
                    return Err(UniNodeLoadError::Fmt(err));
                }
                let content = std::fs::read_to_string(path)
                    .map_err(|e| UniNodeIoError::new(path, e))?;
                formats[ext]
                    .parse(content.as_ref())
                    .map_err(UniNodeLoadError::Fmt)
            },
            None => {
                for (ext, fmt) in FORMATS.read().unwrap().iter() {
                    let full_path = path.with_extension(&ext);
                    if full_path.is_file() {
                        let content = std::fs::read_to_string(&full_path)
                            .map_err(|e| UniNodeIoError::new(full_path, e))?;
                        return fmt
                            .parse(&content)
                            .map_err(UniNodeLoadError::Fmt);
                    }
                }
                Err(UniNodeLoadError::NotFoundLoader)
            },
        }
    }
}