brain-brew-formats 1.0.0-alpha.8

Implementation package: YAML and CrowdAnki codecs for Brain Brew; no public Rust API commitment
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

use std::collections::BTreeMap;
use std::fmt::{self, Write as _};

use brain_brew_core::{InvalidStableId, MediaReference, StableId};
use serde::Deserialize;

use crate::yaml_scalar::{key as yaml_key, scalar as yaml_scalar};

/// Parse a standalone media-map source file.
///
/// The root mapping is the same shape as the canonical deck's inline `media:`
/// section: stable media ID keys mapped to `{ path, sha256 }` values.
pub fn from_str(input: &str) -> Result<BTreeMap<StableId, MediaReference>, MediaMapYamlError> {
    crate::strict_yaml::reject_duplicate_keys(input).map_err(MediaMapYamlError::Parse)?;
    let file: BTreeMap<String, MediaYaml> =
        serde_yaml::from_str(input).map_err(MediaMapYamlError::Parse)?;
    crate::strict_yaml::reject_unintended_scalars(
        input,
        crate::strict_yaml::ScalarPolicy::MediaMap,
    )
    .map_err(MediaMapYamlError::Parse)?;
    file.into_iter()
        .map(|(id, media)| {
            let stable_id = StableId::new(id)?;
            Ok((stable_id.clone(), media.into_media(stable_id)))
        })
        .collect()
}

/// Parse and re-emit a standalone media-map source file using deterministic formatting.
pub fn format_str(input: &str) -> Result<String, MediaMapYamlError> {
    let media = from_str(input)?;
    Ok(to_string(&media))
}

/// Emit a standalone media-map source file using the canonical inline media ordering and scalar rules.
pub fn to_string(media: &BTreeMap<StableId, MediaReference>) -> String {
    if media.is_empty() {
        return "{}\n".to_owned();
    }

    let mut out = String::new();
    for (id, media) in media {
        writeln!(
            out,
            "{}:",
            yaml_key(id.as_str()).expect("stable id is an emittable key")
        )
        .expect("writing to a string cannot fail");
        writeln!(out, "  path: {}", yaml_scalar(&media.path))
            .expect("writing to a string cannot fail");
        writeln!(out, "  sha256: {}", yaml_scalar(&media.sha256))
            .expect("writing to a string cannot fail");
    }
    out
}

#[derive(Debug)]
pub enum MediaMapYamlError {
    Parse(serde_yaml::Error),
    StableId(InvalidStableId),
}

impl fmt::Display for MediaMapYamlError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Parse(error) => write!(f, "failed to parse media map YAML: {error}"),
            Self::StableId(error) => write!(f, "{error}"),
        }
    }
}

impl std::error::Error for MediaMapYamlError {}

impl From<InvalidStableId> for MediaMapYamlError {
    fn from(error: InvalidStableId) -> Self {
        Self::StableId(error)
    }
}

#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct MediaYaml {
    path: String,
    sha256: String,
}

impl MediaYaml {
    fn into_media(self, id: StableId) -> MediaReference {
        MediaReference {
            id,
            path: self.path,
            sha256: self.sha256,
        }
    }
}