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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

//! Host-import resource authority vocabulary.

use super::super::{PluginHandleKind, PluginWorkspaceObserveTaskHandle};
use crate::plugin::WorkspacePath;
use std::fmt::{Debug, Display, Formatter};

/// Host-session proof for a guest-visible workspace observation task resource.
///
/// The handle and revalidation path are produced together at the authorization boundary. Runtime
/// adapters should carry this proof into their resource table instead of reconstructing path
/// authority from parallel local state.
pub(in crate::plugin) struct PluginWorkspaceObserveTaskResourceAuthority {
    /// Identity-scoped task handle reserved for the guest.
    handle: PluginWorkspaceObserveTaskHandle,
    /// Workspace path that authorized the task resource.
    authority_path: WorkspacePath,
}

/// Task-resource authority split by the runtime resource-table boundary.
pub(in crate::plugin) struct PluginWorkspaceObserveTaskResourceAuthorityParts {
    /// Identity-scoped task handle reserved for the guest.
    pub handle: PluginWorkspaceObserveTaskHandle,
    /// Workspace path that authorized the task resource.
    pub authority_path: WorkspacePath,
}

impl PluginWorkspaceObserveTaskResourceAuthority {
    /// Creates task-resource authority from the host-session authorization boundary.
    pub(super) const fn new(
        handle: PluginWorkspaceObserveTaskHandle,
        authority_path: WorkspacePath,
    ) -> Self {
        Self {
            handle,
            authority_path,
        }
    }

    /// Returns the reserved task handle.
    #[must_use]
    #[cfg(test)]
    pub(in crate::plugin) const fn handle(&self) -> &PluginWorkspaceObserveTaskHandle {
        &self.handle
    }

    /// Splits the proof into the pieces retained by the runtime resource table.
    #[must_use]
    pub(in crate::plugin) fn into_parts(self) -> PluginWorkspaceObserveTaskResourceAuthorityParts {
        PluginWorkspaceObserveTaskResourceAuthorityParts {
            handle: self.handle,
            authority_path: self.authority_path,
        }
    }

    /// Builds authority for focused runtime resource tests.
    #[cfg(test)]
    pub(in crate::plugin) const fn for_test(
        handle: PluginWorkspaceObserveTaskHandle,
        authority_path: WorkspacePath,
    ) -> Self {
        Self {
            handle,
            authority_path,
        }
    }
}

impl Debug for PluginWorkspaceObserveTaskResourceAuthority {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> std::fmt::Result {
        formatter
            .debug_struct("PluginWorkspaceObserveTaskResourceAuthority")
            .field("handle", &self.handle)
            .field("authority_path", &self.authority_path)
            .finish()
    }
}

/// Component-model resource rejection shape.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum PluginHostResourceKind {
    /// Borrowed `view-handle` resource.
    ViewHandle,
    /// Borrowed `buffer-handle` resource.
    BufferHandle,
    /// Host-owned `workspace-observe-task` resource.
    WorkspaceObserveTask,
}

impl PluginHostResourceKind {
    /// Stable redacted resource kind text.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::ViewHandle => "view",
            Self::BufferHandle => "buffer",
            Self::WorkspaceObserveTask => "workspace-observe-task",
        }
    }
}

impl From<PluginHandleKind> for PluginHostResourceKind {
    fn from(kind: PluginHandleKind) -> Self {
        match kind {
            PluginHandleKind::View => Self::ViewHandle,
            PluginHandleKind::Buffer => Self::BufferHandle,
        }
    }
}

impl Display for PluginHostResourceKind {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> std::fmt::Result {
        formatter.write_str(self.as_str())
    }
}

/// Component-model resource rejection shape.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum PluginResourceHandleRejectionReason {
    /// The resource table has no live record.
    Missing,
    /// The table record has the wrong host type.
    WrongType,
    /// The table rejected the resource for another bounded reason.
    Unavailable,
}

impl PluginResourceHandleRejectionReason {
    /// Stable redacted resource rejection text.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Missing => "missing",
            Self::WrongType => "wrong-type",
            Self::Unavailable => "unavailable",
        }
    }
}

impl Display for PluginResourceHandleRejectionReason {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> std::fmt::Result {
        formatter.write_str(self.as_str())
    }
}