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

//! Effect admission error vocabulary.

use super::PluginEffectBatchLimitField;
use crate::plugin::PluginIdentity;
use std::{
    fmt::{Debug, Display, Formatter},
    num::NonZeroUsize,
};

/// Plugin effect commit rejection class.
#[derive(Clone, Copy, Eq, PartialEq)]
pub enum PluginEffectCommitErrorKind {
    /// A batch limit was zero.
    ZeroLimit,
    /// The pending effect batch was full.
    TooManyEffects,
}

impl PluginEffectCommitErrorKind {
    /// Stable diagnostic spelling.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::ZeroLimit => "zero-limit",
            Self::TooManyEffects => "too-many-effects",
        }
    }
}

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

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

/// Plugin effect commit failure.
#[derive(Clone, Debug, Eq, PartialEq, thiserror::Error)]
#[non_exhaustive]
pub enum PluginEffectCommitError {
    /// Effect limit was zero.
    ZeroLimit {
        /// Limit field name.
        field: PluginEffectBatchLimitField,
    },
    /// Effect limit was exceeded.
    TooManyEffects {
        /// Stable plugin identity.
        identity: PluginIdentity,
        /// Maximum accepted effects.
        limit: NonZeroUsize,
    },
}

impl PluginEffectCommitError {
    /// Closed rejection class for caller decisions and diagnostics.
    #[must_use]
    pub const fn kind(&self) -> PluginEffectCommitErrorKind {
        match self {
            Self::ZeroLimit { .. } => PluginEffectCommitErrorKind::ZeroLimit,
            Self::TooManyEffects { .. } => PluginEffectCommitErrorKind::TooManyEffects,
        }
    }
}

impl Display for PluginEffectCommitError {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::ZeroLimit { .. } => formatter.write_str("plugin effect limit must be non-zero"),
            Self::TooManyEffects { identity, limit } => {
                let identity = identity.as_str();
                let limit = limit.get();
                write!(
                    formatter,
                    "plugin {identity:?} exceeded effect limit of {limit}"
                )
            }
        }
    }
}