nematic 0.1.0

Portable smolweb rendering engine — Gemini, Gopher, Markdown, feeds, and the knot note format, lowered to the inker document model.
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
132
133
134

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */

//! Misfin engine — body-shape parser for Misfin (`misfin://`) gemini-style
//! peer-to-peer mail (<https://misfin.org>).
//!
//! Misfin messages are a sender / recipient / timestamp / certificate
//! envelope wrapped around a gemtext body. Addressing is `name@domain`-shaped
//! and tied to client certificates.
//!
//! Envelope decoding (sender / recipient / timestamp / cert verification)
//! happens in the host transport. The engine receives the body and parses
//! it as gemtext, attaching a [`DocumentDiagnostic`] noting that the
//! envelope wasn't validated here. Trust stays `Unknown` until the host
//! overrides it after cert verification.

use inker::{
    DocumentDiagnostic, DocumentProvenance, DocumentTrustState, Engine, EngineDocument,
    EngineError, EngineInput,
};

use crate::GemtextEngine;

/// Stable engine identifier.
pub const ENGINE_ID: &str = "nematic.misfin";

/// Misfin message body engine.
pub struct MisfinEngine {
    gemtext: GemtextEngine,
}

impl MisfinEngine {
    pub fn new() -> Self {
        Self {
            gemtext: GemtextEngine::new(),
        }
    }
}

impl Default for MisfinEngine {
    fn default() -> Self {
        Self::new()
    }
}

impl Engine for MisfinEngine {
    fn engine_id(&self) -> &str {
        ENGINE_ID
    }

    fn render(&self, input: &EngineInput) -> Result<EngineDocument, EngineError> {
        let mut doc = self.gemtext.render(input)?;

        // Override provenance with this engine; preserve gemtext's ID as the
        // dispatched-through label.
        doc.provenance = DocumentProvenance {
            source_kind: Some(self.engine_id().to_string()),
            canonical_uri: Some(input.address.clone()),
            fetched_at: None,
            source_label: Some("nematic.gemtext".to_string()),
        };

        // Tag the content type with the misfin-specific media type when the
        // host hasn't supplied one.
        if input.content_type.is_none() {
            doc.content_type = "message/x-misfin".to_string();
        }

        doc.trust = DocumentTrustState::Unknown;
        doc.diagnostics
            .push(DocumentDiagnostic::UnsupportedConstruct(
                "misfin envelope (sender / recipient / timestamp / certificate) not parsed by this engine"
                    .to_string(),
            ));

        Ok(doc)
    }
}

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

    fn render(body: &str) -> EngineDocument {
        MisfinEngine::new()
            .render(&EngineInput::new("misfin://alice@example.test", body))
            .expect("render")
    }

    #[test]
    fn engine_id_is_stable() {
        assert_eq!(MisfinEngine::new().engine_id(), "nematic.misfin");
    }

    #[test]
    fn body_parses_as_gemtext() {
        let doc = render("# Hello, Bob\n\n=> gemini://example.test/ Capsule\n");
        assert_eq!(doc.title.as_deref(), Some("Hello, Bob"));
        assert_eq!(doc.outgoing_links(), vec!["gemini://example.test/"]);
    }

    #[test]
    fn provenance_records_misfin_with_gemtext_label() {
        let doc = render("Hi.\n");
        assert_eq!(
            doc.provenance.source_kind.as_deref(),
            Some("nematic.misfin")
        );
        assert_eq!(
            doc.provenance.source_label.as_deref(),
            Some("nematic.gemtext")
        );
    }

    #[test]
    fn content_type_defaults_to_misfin_message() {
        let doc = render("Hi.\n");
        assert_eq!(doc.content_type, "message/x-misfin");
    }

    #[test]
    fn missing_envelope_verification_emits_diagnostic() {
        let doc = render("Hi.\n");
        let has_warning = doc.diagnostics.iter().any(|d| {
            matches!(
                d,
                DocumentDiagnostic::UnsupportedConstruct(msg)
                    if msg.contains("envelope") && msg.contains("certificate")
            )
        });
        assert!(has_warning, "expected envelope-not-parsed diagnostic");
    }
}