alma 0.1.1

A Bevy-native modal text editor with Vim-style navigation.
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

//! Wasmtime component bindings.

wasmtime::component::bindgen!({
    path: "wit",
    world: "plugin",
    with: {
        "alma:editor/host.buffer-handle": crate::plugin::PluginBufferHandle,
        "alma:editor/host.view-handle": crate::plugin::PluginViewHandle,
        "alma:editor/host.workspace-observe-task": crate::plugin::PluginWorkspaceObserveTaskHandle,
    },
    imports: { default: trappable },
});

use super::WitCapability;

/// Returns the generated WIT capability vocabulary converted into Alma's stable type.
#[must_use]
pub const fn generated_capabilities() -> [WitCapability; 5] {
    [
        wit_capability_to_alma(alma::editor::host::Capability::BufferObserve),
        wit_capability_to_alma(alma::editor::host::Capability::BufferProposeEdit),
        wit_capability_to_alma(alma::editor::host::Capability::WorkspaceObserve),
        wit_capability_to_alma(alma::editor::host::Capability::WorkspaceArtifactWrite),
        wit_capability_to_alma(alma::editor::host::Capability::StatusPublish),
    ]
}

/// Converts generated WIT capability variants into Alma's host authorization vocabulary.
const fn wit_capability_to_alma(capability: alma::editor::host::Capability) -> WitCapability {
    match capability {
        alma::editor::host::Capability::BufferObserve => WitCapability::BufferObserve,
        alma::editor::host::Capability::BufferProposeEdit => WitCapability::BufferProposeEdit,
        alma::editor::host::Capability::WorkspaceObserve => WitCapability::WorkspaceObserve,
        alma::editor::host::Capability::WorkspaceArtifactWrite => {
            WitCapability::WorkspaceArtifactWrite
        }
        alma::editor::host::Capability::StatusPublish => WitCapability::StatusPublish,
    }
}

#[cfg(test)]
mod tests {
    use super::generated_capabilities;
    use crate::plugin::{PluginCapabilityRef, WitCapability, WitCapabilityRefError};

    #[test]
    fn generated_wit_resources_match_handle_vocabulary() {
        assert!(
            std::any::type_name::<super::alma::editor::host::BufferHandle>()
                .ends_with("BufferHandle")
        );
        assert!(
            std::any::type_name::<super::alma::editor::host::ViewHandle>().ends_with("ViewHandle")
        );
        assert!(
            std::any::type_name::<super::alma::editor::host::WorkspaceObserveTask>()
                .contains("WorkspaceObserveTask")
        );
    }

    #[test]
    fn generated_wit_capabilities_match_alma_vocabulary() {
        assert_eq!(generated_capabilities(), WitCapability::all());
    }

    #[test]
    fn generated_wit_capabilities_map_to_authorization_refs() {
        for capability in generated_capabilities() {
            match capability {
                WitCapability::BufferObserve => {
                    assert_eq!(
                        capability.as_ref(None),
                        Ok(PluginCapabilityRef::BufferObserve)
                    );
                }
                WitCapability::BufferProposeEdit => {
                    assert_eq!(
                        capability.as_ref(None),
                        Ok(PluginCapabilityRef::BufferProposeEdit)
                    );
                }
                WitCapability::StatusPublish => {
                    assert_eq!(
                        capability.as_ref(None),
                        Ok(PluginCapabilityRef::StatusPublish)
                    );
                }
                WitCapability::WorkspaceObserve => {
                    assert!(matches!(
                        capability.as_ref(None),
                        Err(WitCapabilityRefError::MissingPath { .. })
                    ));
                    assert!(matches!(
                        capability.as_ref(Some("docs/arch.md")),
                        Ok(PluginCapabilityRef::WorkspaceObserve(_))
                    ));
                }
                WitCapability::WorkspaceArtifactWrite => {
                    assert!(matches!(
                        capability.as_ref(None),
                        Err(WitCapabilityRefError::MissingPath { .. })
                    ));
                    assert!(matches!(
                        capability.as_ref(Some("docs/arch.md")),
                        Ok(PluginCapabilityRef::WorkspaceArtifactWrite(_))
                    ));
                }
            }
        }
    }
}