merman-bindings-core 0.7.0

Safe shared binding facade for merman native bindings.
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

#![forbid(unsafe_code)]

//! Safe shared facade used by external binding crates.
//!
//! This crate owns options parsing, renderer setup, result-code classification, and byte payload
//! production. Unsafe transport concerns such as raw pointers and owned C buffers remain in
//! `merman-ffi`.

mod common;
mod engine;
mod metadata;

#[cfg(feature = "ascii")]
mod ascii;
#[cfg(feature = "render")]
mod render;

pub use common::{BindingError, BindingStatus, error_payload_json_bytes};
pub use engine::BindingEngine;
pub use metadata::{
    ascii_supported_diagrams, ascii_supported_diagrams_json, supported_diagrams,
    supported_diagrams_json, supported_host_theme_presets, supported_host_theme_presets_json,
    supported_themes, supported_themes_json,
};

#[cfg(feature = "ascii")]
pub use ascii::render_ascii;
#[cfg(feature = "render")]
pub use render::{layout_json, parse_json, render_svg, validate_json};

#[cfg(not(feature = "ascii"))]
pub fn render_ascii(source: &[u8], options_json: &[u8]) -> Result<Vec<u8>, BindingError> {
    let _ = (source, options_json);
    Err(common::feature_required_error("ASCII rendering", "ascii"))
}

#[cfg(not(feature = "render"))]
pub fn render_svg(source: &[u8], options_json: &[u8]) -> Result<Vec<u8>, BindingError> {
    let _ = (source, options_json);
    Err(common::feature_required_error("SVG rendering", "render"))
}

#[cfg(not(feature = "render"))]
pub fn parse_json(source: &[u8], options_json: &[u8]) -> Result<Vec<u8>, BindingError> {
    let _ = (source, options_json);
    Err(common::feature_required_error("parse_json", "render"))
}

#[cfg(not(feature = "render"))]
pub fn layout_json(source: &[u8], options_json: &[u8]) -> Result<Vec<u8>, BindingError> {
    let _ = (source, options_json);
    Err(common::feature_required_error("layout_json", "render"))
}

#[cfg(not(feature = "render"))]
pub fn validate_json(source: &[u8], options_json: &[u8]) -> Result<Vec<u8>, BindingError> {
    let _ = (source, options_json);
    common::validation_payload_json(Err(common::feature_required_error("validation", "render")))
}

#[cfg(all(test, any(not(feature = "render"), not(feature = "ascii"))))]
mod tests {
    use super::*;
    #[cfg(not(feature = "render"))]
    use serde_json::Value;

    #[cfg(not(feature = "render"))]
    #[test]
    fn render_entry_points_report_missing_render_feature() {
        let err = render_svg(b"flowchart TD\nA", b"").unwrap_err();
        assert_eq!(err.status(), BindingStatus::UnsupportedFormat);
        assert!(err.message().contains("render feature"));

        let err = parse_json(b"flowchart TD\nA", b"").unwrap_err();
        assert_eq!(err.status(), BindingStatus::UnsupportedFormat);

        let err = layout_json(b"flowchart TD\nA", b"").unwrap_err();
        assert_eq!(err.status(), BindingStatus::UnsupportedFormat);

        let validation: Value =
            serde_json::from_slice(&validate_json(b"flowchart TD\nA", b"").unwrap()).unwrap();
        assert_eq!(validation["valid"], false);
        assert_eq!(
            validation["code_name"],
            BindingStatus::UnsupportedFormat.code_name()
        );
    }

    #[cfg(not(feature = "ascii"))]
    #[test]
    fn ascii_entry_point_reports_missing_ascii_feature() {
        let err = render_ascii(b"flowchart TD\nA", b"").unwrap_err();
        assert_eq!(err.status(), BindingStatus::UnsupportedFormat);
        assert!(err.message().contains("ascii feature"));
    }
}