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

//! Error taxonomy for buffer-owner ECS boundaries.

use crate::{
    ecs::events::{
        command::CommandFailureDiagnostic,
        operation::{OperationFailureClass, OperationFailureSource, OperationRetryAdvice},
    },
    fs_utils::FileWriteError,
    vim::VimError,
};

/// Structured command failure retained at the owner boundary.
#[derive(Debug)]
pub(super) enum BufferCommandError {
    /// A command failed with native Vim semantics.
    Vim(VimError),
    /// A write command failed after filesystem policy or persistence validation.
    Write(FileWriteError),
    /// Filesystem policy was not installed for a command that requires persistence.
    FilesystemUnavailable,
}

impl BufferCommandError {
    /// Returns the boundary class that determines disclosure and recovery.
    pub(super) const fn class(&self) -> OperationFailureClass {
        match self {
            Self::Vim(_) => OperationFailureClass::UserVisible,
            Self::Write(_) => OperationFailureClass::Persistence,
            Self::FilesystemUnavailable => OperationFailureClass::RuntimeConfig,
        }
    }

    /// Returns the safe Vim-facing status error.
    pub(super) const fn status_error(&self) -> VimError {
        match self {
            Self::Vim(error) => *error,
            Self::Write(_) | Self::FilesystemUnavailable => VimError::CantOpenFileForWriting,
        }
    }

    /// Returns the redacted diagnostic shape for production telemetry.
    pub(super) fn diagnostic(&self) -> CommandFailureDiagnostic {
        CommandFailureDiagnostic {
            class: self.class(),
            status_error: self.status_error(),
            source: self.source_shape(),
            retry: self.retry_advice(),
        }
    }

    /// Returns a redacted lower-boundary source shape.
    fn source_shape(&self) -> Option<OperationFailureSource> {
        match self {
            Self::Write(error) => Some(OperationFailureSource::from_file_write_error(error)),
            Self::Vim(_) | Self::FilesystemUnavailable => None,
        }
    }

    /// Returns the typed persistence failure, if one exists.
    pub(super) const fn write_error(&self) -> Option<&FileWriteError> {
        match self {
            Self::Write(error) => Some(error),
            Self::Vim(_) | Self::FilesystemUnavailable => None,
        }
    }

    /// Returns retry guidance for the same command request.
    pub(super) fn retry_advice(&self) -> OperationRetryAdvice {
        match self {
            Self::Write(error) => {
                OperationFailureSource::from_file_write_error(error).retry_advice()
            }
            Self::Vim(_) | Self::FilesystemUnavailable => OperationRetryAdvice::RetryAfterChange,
        }
    }
}