indigo_core/

editor.rs

use crate::{
    buffer::{Buffer, BufferKey},
    fs::{Fs, NoFs},
    key::Key,
    mode::{Mode, command, insert, normal, prompt, replace, seek},
    window::{Window, WindowKey, WindowMut, WindowState},
};
use camino::Utf8PathBuf;
use indigo_kernel::IndigoBuildHasher;
use slotmap::SlotMap;
use std::{collections::HashMap, num::NonZeroUsize, process::ExitCode, sync::Arc};
use thiserror::Error;

#[cfg(feature = "arbitrary")]
use arbitrary::Arbitrary;

#[derive(Debug, Error)]
pub enum Error {
    #[error("Focused window {key:?} does not exist")]
    FocusedWindowMissing { key: WindowKey },

    #[error("Window {window_key:?} refers to buffer {buffer_key:?}, which does not exist")]
    WindowBufferMissing {
        window_key: WindowKey,
        buffer_key: BufferKey,
    },

    #[error("Error from buffer {key:?}")]
    Buffer {
        key: BufferKey,
        #[source]
        source: anyhow::Error,
    },

    #[error("Error from window {key:?}")]
    Window {
        key: WindowKey,
        #[source]
        source: anyhow::Error,
    },

    #[error("Error from prompt")]
    Prompt(#[source] anyhow::Error),
}

#[derive(Clone)]
pub struct Editor {
    pub fs: Arc<dyn Fs + Send + Sync>,
    buffers: SlotMap<BufferKey, Buffer>,
    windows: SlotMap<WindowKey, WindowState>,
    focused_window: WindowKey,
    pub registers: HashMap<char, Vec<String>, IndigoBuildHasher>,
    pub mode: Mode,
    pub count: Option<NonZeroUsize>,
    pub pending_keys: Vec<Key>,
    pub pwd: Option<Utf8PathBuf>,
    pub message: Option<Result<String, String>>,
    exit_code: Option<ExitCode>,
}

impl Editor {
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }

    // TODO: Figure out a safer/better way to add and remove buffers
    pub(crate) fn insert_buffer(&mut self, buffer: Buffer) -> BufferKey {
        self.buffers.insert(buffer)
    }

    #[must_use]
    pub fn get_buffer(&self, buffer_key: BufferKey) -> Option<&Buffer> {
        self.buffers.get(buffer_key)
    }

    #[must_use]
    pub fn get_buffer_mut(&mut self, buffer_key: BufferKey) -> Option<&mut Buffer> {
        self.buffers.get_mut(buffer_key)
    }

    #[must_use]
    pub fn focused_buffer(&self) -> &Buffer {
        let window = self
            .windows
            .get(self.focused_window)
            .expect("Window state is always kept valid");
        self.buffers
            .get(window.buffer)
            .expect("Window state is always kept valid")
    }

    #[must_use]
    pub fn focused_buffer_mut(&mut self) -> &mut Buffer {
        let window = self
            .windows
            .get_mut(self.focused_window)
            .expect("Window state is always kept valid");
        self.buffers
            .get_mut(window.buffer)
            .expect("Window state is always kept valid")
    }

    pub fn buffers(&self) -> impl Iterator<Item = (BufferKey, &Buffer)> {
        self.buffers.iter()
    }

    pub fn buffers_mut(&mut self) -> impl Iterator<Item = (BufferKey, &mut Buffer)> {
        self.buffers.iter_mut()
    }

    // TODO: Figure out a safer/better way to add and remove windows
    pub(crate) fn insert_window(&mut self, window: WindowState) -> WindowKey {
        assert!(
            self.buffers.contains_key(window.buffer),
            "Window has invalid buffer key"
        );
        self.windows.insert(window)
    }

    pub fn focus_window(&mut self, window_key: WindowKey) -> bool {
        if self.windows.contains_key(window_key) {
            self.focused_window = window_key;
            true
        } else {
            false
        }
    }

    #[must_use]
    pub fn get_window(&self, window_key: WindowKey) -> Option<Window<'_>> {
        let window = self.windows.get(window_key)?;
        let buffer = self
            .buffers
            .get(window.buffer)
            .expect("Window state is always kept valid");
        Some(Window::new(buffer, window))
    }

    #[must_use]
    pub fn get_window_mut(&mut self, window_key: WindowKey) -> Option<WindowMut<'_>> {
        let window = self.windows.get_mut(window_key)?;
        let buffer = self
            .buffers
            .get_mut(window.buffer)
            .expect("Window state is always kept valid");
        Some(WindowMut::new(buffer, window))
    }

    pub fn focused_window(&self) -> Window<'_> {
        let window = self
            .windows
            .get(self.focused_window)
            .expect("Window state is always kept valid");
        let buffer = self
            .buffers
            .get(window.buffer)
            .expect("Window state is always kept valid");
        Window::new(buffer, window)
    }

    pub fn focused_window_mut(&mut self) -> WindowMut<'_> {
        let window = self
            .windows
            .get_mut(self.focused_window)
            .expect("Window state is always kept valid");
        let buffer = self
            .buffers
            .get_mut(window.buffer)
            .expect("Window state is always kept valid");
        WindowMut::new(buffer, window)
    }

    // TODO: Add windows iterator

    #[must_use]
    pub fn exit_code(&self) -> Option<ExitCode> {
        self.exit_code
    }

    /// Doesn't actually terminate the process, just records the desired exit code.
    pub fn exit(&mut self, exit_code: u8) {
        self.exit_code = Some(ExitCode::from(exit_code));
    }

    pub fn handle_event(&mut self, mut event: Event) -> anyhow::Result<bool> {
        #[expect(irrefutable_let_patterns)]
        if let Event::Key(KeyEvent { key, .. }) = &mut event {
            key.normalize();
            self.pending_keys.push(*key);
        }

        let handled = match event {
            Event::Key(_) => match self.mode {
                Mode::Normal => normal::handle_keys(self),
                Mode::Seek(_) => seek::handle_keys(self),
                Mode::Insert => insert::handle_keys(self),
                Mode::Prompt(_) => prompt::handle_keys(self),
                Mode::Replace => replace::handle_keys(self),
            },
        };

        self.assert_invariants().unwrap();

        Ok(handled)
    }

    pub fn handle_action(&mut self, action: &Action) {
        match action {
            Action::Normal(action) => normal::handle_action(self, action),
            Action::Insert(action) => insert::handle_action(self, action),
            Action::Prompt(action) => prompt::handle_action(self, action),
            Action::Command(action) => command::handle_action(self, action),
            Action::Seek(action) => seek::handle_action(self, action),
        }
        self.assert_invariants().unwrap();
    }

    pub fn assert_invariants(&self) -> anyhow::Result<()> {
        if !self.windows.contains_key(self.focused_window) {
            anyhow::bail!(Error::FocusedWindowMissing {
                key: self.focused_window,
            });
        }
        for (key, buffer) in &self.buffers {
            buffer
                .assert_invariants()
                .map_err(|source| Error::Buffer { key, source })?;
        }
        for (window_key, window) in &self.windows {
            let Some(buffer) = self.buffers.get(window.buffer) else {
                anyhow::bail!(Error::WindowBufferMissing {
                    window_key,
                    buffer_key: window.buffer,
                });
            };
            Window::new(buffer, window)
                .assert_invariants()
                .map_err(|source| Error::Window {
                    key: window_key,
                    source,
                })?;
        }
        if let Mode::Prompt(state) = &self.mode {
            state.assert_invariants().map_err(Error::Prompt)?;
        }
        Ok(())
    }
}

impl Default for Editor {
    fn default() -> Self {
        let mut buffers = SlotMap::default();
        let buffer = Buffer::default();
        let buffer_key = buffers.insert(buffer);

        let window = WindowState::new(buffer_key);
        let mut windows = SlotMap::default();
        let window_key = windows.insert(window);

        Self {
            fs: Arc::new(NoFs),
            buffers,
            windows,
            focused_window: window_key,
            registers: HashMap::default(),
            mode: Mode::default(),
            count: None,
            pending_keys: Vec::new(),
            pwd: None,
            message: None,
            exit_code: None,
        }
    }
}

impl From<Buffer> for Editor {
    fn from(buffer: Buffer) -> Self {
        let mut buffers = SlotMap::default();
        let buffer_key = buffers.insert(buffer);

        let window = WindowState::new(buffer_key);
        let mut windows = SlotMap::default();
        let window_key = windows.insert(window);

        Self {
            buffers,
            windows,
            focused_window: window_key,
            ..Self::default()
        }
    }
}

#[cfg_attr(feature = "arbitrary", derive(Arbitrary))]
#[derive(Debug)]
pub enum Event {
    Key(KeyEvent),
}

#[cfg_attr(feature = "arbitrary", derive(Arbitrary))]
#[derive(Debug, PartialEq)]
pub struct KeyEvent {
    pub key: Key,
    pub kind: KeyEventKind,
}

#[cfg_attr(feature = "arbitrary", derive(Arbitrary))]
#[derive(Debug, PartialEq)]
pub enum KeyEventKind {
    Press,
    Repeat,
    Release,
}

#[cfg_attr(feature = "arbitrary", derive(Arbitrary))]
#[derive(Debug)]
pub enum Action {
    Normal(normal::Action),
    Insert(insert::Action),
    Prompt(prompt::Action),
    Command(command::Action),
    // TODO: Replace this with multi-key mappings in normal mode
    Seek(seek::Action),
}