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

//! Buffer ECS components.

use crate::{
    buffer::UndoStack,
    text_stream::{TextByteStream, TextByteStreamShape, TextRevision},
};
use bevy::prelude::{Component, Entity};
use std::fmt::{Debug, Formatter};

/// Typed ECS identity for an authoritative editor buffer entity.
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
pub struct BufferEntity(pub Entity);

impl BufferEntity {
    /// Returns the raw Bevy entity.
    pub const fn get(self) -> Entity {
        self.0
    }
}

/// Typed ECS identity for an editor view entity.
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
pub struct ViewEntity(pub Entity);

impl ViewEntity {
    /// Returns the raw Bevy entity.
    pub const fn get(self) -> Entity {
        self.0
    }
}

/// Marker for the current editor buffer entity.
#[derive(Clone, Copy, Component, Debug, Default, Eq, PartialEq)]
pub struct EditorBuffer;

/// Interactive editor view over an authoritative buffer.
#[derive(Clone, Copy, Component, Debug, Eq, PartialEq)]
pub struct EditorView {
    /// Buffer whose text and persistence state this view observes.
    pub buffer: BufferEntity,
}

/// Marker for the editor view currently receiving input and chrome sync.
#[derive(Clone, Copy, Component, Debug, Default, Eq, PartialEq)]
pub struct FocusedEditorView;

/// Authoritative text attached to an editor buffer entity.
#[derive(Clone, Component, Default, Eq, PartialEq)]
pub struct BufferText {
    /// Validated UTF-8 text stream.
    pub stream: TextByteStream,
}

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

/// Redacted buffer text diagnostic shape.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct BufferTextShape {
    /// Redacted stream shape.
    stream: TextByteStreamShape,
}

impl BufferTextShape {
    /// Builds a redacted diagnostic shape from authoritative buffer text.
    #[must_use]
    pub fn from_buffer_text(buffer_text: &BufferText) -> Self {
        Self::from(buffer_text)
    }

    /// Returns the redacted stream shape.
    #[must_use]
    pub const fn stream(self) -> TextByteStreamShape {
        self.stream
    }
}

impl From<&BufferText> for BufferTextShape {
    fn from(buffer_text: &BufferText) -> Self {
        Self {
            stream: TextByteStreamShape::from(&buffer_text.stream),
        }
    }
}

/// Cached stream revision for systems that need cheap revision checks.
#[derive(Clone, Copy, Component, Debug, Default, Eq, PartialEq)]
pub struct BufferRevision {
    /// Monotonic buffer revision.
    pub revision: TextRevision,
}

/// Bounded undo and redo history attached to one authoritative buffer.
#[derive(Clone, Component, Debug, Default, Eq, PartialEq)]
pub struct BufferUndoHistory {
    /// Redacted undo stack. The stack stores user text but never exposes it through `Debug`.
    stack: UndoStack,
}

impl BufferUndoHistory {
    /// Returns mutable access for the buffer owner system.
    pub const fn stack_mut(&mut self) -> &mut UndoStack {
        &mut self.stack
    }

    /// Returns shared access for tests and diagnostics.
    #[must_use]
    pub const fn stack(&self) -> &UndoStack {
        &self.stack
    }
}

#[cfg(test)]
mod tests {
    use super::BufferText;
    use crate::text_stream::TextByteStream;

    #[test]
    fn buffer_text_debug_output_redacts_stream_text() {
        let buffer_text = BufferText {
            stream: TextByteStream::new("secret buffer text"),
        };
        let debug = format!("{buffer_text:?}");

        assert!(debug.contains("BufferText"));
        assert!(debug.contains("byte_len"));
        assert!(!debug.contains("secret"));
        assert!(!debug.contains("buffer text"));
    }
}