snekdown 0.33.4

A parser for the custom snekdown markdown syntax
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
124
125
126
127
128
129
130
131

/*
 * Snekdown - Custom Markdown flavour and parser
 * Copyright (C) 2021  Trivernis
 * See LICENSE for more information.
 */

use crate::elements::{Metadata, MetadataValue};
use crate::settings::feature_settings::FeatureSettings;
use crate::settings::image_settings::ImageSettings;
use crate::settings::import_settings::ImportSettings;
use crate::settings::metadata_settings::MetadataSettings;
use crate::settings::pdf_settings::PDFSettings;
use crate::settings::style_settings::StyleSettings;
use config::{ConfigError, Source};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::error::Error;
use std::fmt::{self, Display};
use std::io;
use std::mem;
use std::path::PathBuf;

pub mod feature_settings;
pub mod image_settings;
pub mod import_settings;
pub mod metadata_settings;
pub mod pdf_settings;
pub mod style_settings;

pub type SettingsResult<T> = Result<T, SettingsError>;

#[derive(Debug)]
pub enum SettingsError {
    IoError(io::Error),
    ConfigError(ConfigError),
    TomlError(toml::ser::Error),
}

impl Display for SettingsError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::IoError(e) => write!(f, "IO Error: {}", e),
            Self::ConfigError(e) => write!(f, "Config Error: {}", e),
            Self::TomlError(e) => write!(f, "Toml Error: {}", e),
        }
    }
}

impl Error for SettingsError {}

impl From<io::Error> for SettingsError {
    fn from(e: io::Error) -> Self {
        Self::IoError(e)
    }
}

impl From<ConfigError> for SettingsError {
    fn from(e: ConfigError) -> Self {
        Self::ConfigError(e)
    }
}

impl From<toml::ser::Error> for SettingsError {
    fn from(e: toml::ser::Error) -> Self {
        Self::TomlError(e)
    }
}

#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct Settings {
    pub metadata: MetadataSettings,
    pub features: FeatureSettings,
    pub imports: ImportSettings,
    pub pdf: PDFSettings,
    pub images: ImageSettings,
    pub style: StyleSettings,
    pub custom_attributes: HashMap<String, String>,
}

impl Source for Settings {
    fn clone_into_box(&self) -> Box<dyn Source + Send + Sync> {
        Box::new(self.clone())
    }

    fn collect(&self) -> Result<HashMap<String, config::Value>, config::ConfigError> {
        let source_str =
            toml::to_string(&self).map_err(|e| config::ConfigError::Foreign(Box::new(e)))?;
        let result = toml::de::from_str(&source_str)
            .map_err(|e| config::ConfigError::Foreign(Box::new(e)))?;

        Ok(result)
    }
}

impl Settings {
    /// Loads the settings from the specified path
    pub fn load(path: PathBuf) -> SettingsResult<Self> {
        let mut settings = config::Config::default();
        settings
            .merge(Self::default())?
            .merge(config::File::from(path))?;
        let settings: Self = settings.try_into()?;

        Ok(settings)
    }

    /// Merges the current settings with the settings from the given path
    /// returning updated settings
    pub fn merge(&mut self, path: PathBuf) -> SettingsResult<()> {
        let mut settings = config::Config::default();
        settings
            .merge(self.clone())?
            .merge(config::File::from(path))?;
        let mut settings: Self = settings.try_into()?;
        mem::swap(self, &mut settings); // replace the old settings with the new ones

        Ok(())
    }

    pub fn append_metadata<M: Metadata>(&mut self, metadata: M) {
        let entries = metadata.get_string_map();
        for (key, value) in entries {
            self.custom_attributes.insert(key, value);
        }
    }

    pub fn set_from_meta(&mut self, key: &str, value: MetadataValue) {
        self.custom_attributes
            .insert(key.to_string(), value.to_string());
    }
}