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

//! Vim adapter effects.

use crate::ecs::events::{
    command::CommandRequested,
    cursor::CursorMoveRequested,
    edit::{BufferEditRequested, EditHistoryRequested},
    intent::ViewportIntent,
    status::StatusMessageRequested,
};
use bevy::prelude::MessageWriter;

/// ECS requests collected during Vim interpretation.
#[derive(Clone, Debug, Eq, PartialEq)]
pub(super) enum VimEffect {
    /// Buffer edit request.
    BufferEdit(BufferEditRequested),
    /// Undo or redo request.
    EditHistory(EditHistoryRequested),
    /// Cursor move.
    CursorMove(CursorMoveRequested),
    /// Viewport placement.
    Viewport(ViewportIntent),
    /// Status update.
    Status(StatusMessageRequested),
    /// Command request.
    Command(CommandRequested),
}

/// Ordered adapter-local effects produced by one input dispatch.
///
/// The batch is the commit point before typed ECS messages. Vim interpretation
/// may populate it, but authoritative mutation still belongs to owner systems.
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub(super) struct VimEffectBatch {
    /// Ordered effects waiting to cross into ECS messages.
    effects: Vec<VimEffect>,
}

impl VimEffectBatch {
    /// Appends one effect to the batch.
    pub(super) fn push(&mut self, effect: VimEffect) {
        self.effects.push(effect);
    }

    /// Appends multiple effects preserving iterator order.
    pub(super) fn extend(&mut self, effects: impl IntoIterator<Item = VimEffect>) {
        self.effects.extend(effects);
    }

    /// Reads the ordered effects.
    pub(super) fn as_slice(&self) -> &[VimEffect] {
        &self.effects
    }
}

/// Vim effect sinks.
#[derive(bevy::ecs::system::SystemParam)]
pub struct VimEffectWriters<'w> {
    /// Buffer edits.
    buffer_edits: MessageWriter<'w, BufferEditRequested>,
    /// Edit-history replay requests.
    edit_history: MessageWriter<'w, EditHistoryRequested>,
    /// Cursor moves.
    cursor_moves: MessageWriter<'w, CursorMoveRequested>,
    /// Viewport intents.
    viewport_intents: MessageWriter<'w, ViewportIntent>,
    /// Status requests.
    status_requests: MessageWriter<'w, StatusMessageRequested>,
    /// Command requests.
    command_requests: MessageWriter<'w, CommandRequested>,
}

impl VimEffectWriters<'_> {
    /// Emits collected effects.
    pub(super) fn emit(&mut self, effects: &VimEffectBatch) {
        for effect in effects.as_slice() {
            match effect {
                VimEffect::BufferEdit(request) => {
                    let _sent = self.buffer_edits.write(request.clone());
                }
                VimEffect::EditHistory(request) => {
                    let _sent = self.edit_history.write(*request);
                }
                VimEffect::CursorMove(request) => {
                    let _sent = self.cursor_moves.write(*request);
                }
                VimEffect::Viewport(intent) => {
                    let _sent = self.viewport_intents.write(*intent);
                }
                VimEffect::Status(request) => {
                    let _sent = self.status_requests.write(request.clone());
                }
                VimEffect::Command(request) => {
                    let _sent = self.command_requests.write(*request);
                }
            }
        }
    }
}