Added fed artist page

src/app/input.rs

@@ -0,0 +1,147 @@
+//! One-line text editing with a movable cursor, shared by every text input
+//! (command line, edit forms, popup fields).
+
+use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
+
+/// A single-line value plus a cursor position (in characters). Dereferences
+/// to `&str`, so read paths treat it like the plain string it wraps.
+#[derive(Debug, Clone, Default)]
+pub struct LineEdit {
+    value: String,
+    cursor: usize,
+}
+
+impl LineEdit {
+    /// Starts with `value` and the cursor at its end.
+    pub fn new(value: impl Into<String>) -> Self {
+        let value = value.into();
+        let cursor = value.chars().count();
+        Self { value, cursor }
+    }
+
+    pub fn as_str(&self) -> &str {
+        &self.value
+    }
+
+    /// Cursor position in characters (0..=len).
+    pub fn cursor(&self) -> usize {
+        self.cursor
+    }
+
+    fn byte_index(&self, chars: usize) -> usize {
+        self.value
+            .char_indices()
+            .nth(chars)
+            .map(|(index, _)| index)
+            .unwrap_or(self.value.len())
+    }
+
+    pub fn clear(&mut self) {
+        self.value.clear();
+        self.cursor = 0;
+    }
+
+    pub fn insert(&mut self, c: char) {
+        let at = self.byte_index(self.cursor);
+        self.value.insert(at, c);
+        self.cursor += 1;
+    }
+
+    pub fn insert_str(&mut self, s: &str) {
+        let at = self.byte_index(self.cursor);
+        self.value.insert_str(at, s);
+        self.cursor += s.chars().count();
+    }
+
+    /// Removes the character before the cursor; `false` when at the start.
+    pub fn backspace(&mut self) -> bool {
+        if self.cursor == 0 {
+            return false;
+        }
+        let at = self.byte_index(self.cursor - 1);
+        self.value.remove(at);
+        self.cursor -= 1;
+        true
+    }
+
+    /// Removes the character under the cursor.
+    pub fn delete(&mut self) {
+        if self.cursor < self.value.chars().count() {
+            let at = self.byte_index(self.cursor);
+            self.value.remove(at);
+        }
+    }
+
+    /// Applies one editing key (characters, backspace/delete, cursor
+    /// movement). Returns `false` for keys this editor does not handle
+    /// (Enter, Esc, Tab, ...), which the caller interprets itself.
+    pub fn handle_key(&mut self, key: KeyEvent) -> bool {
+        match key.code {
+            KeyCode::Char(c) if key.modifiers.difference(KeyModifiers::SHIFT).is_empty() => {
+                self.insert(c);
+            }
+            KeyCode::Backspace => {
+                self.backspace();
+            }
+            KeyCode::Delete => self.delete(),
+            KeyCode::Left => self.cursor = self.cursor.saturating_sub(1),
+            KeyCode::Right => self.cursor = (self.cursor + 1).min(self.value.chars().count()),
+            KeyCode::Home => self.cursor = 0,
+            KeyCode::End => self.cursor = self.value.chars().count(),
+            _ => return false,
+        }
+        true
+    }
+}
+
+impl std::ops::Deref for LineEdit {
+    type Target = str;
+
+    fn deref(&self) -> &str {
+        &self.value
+    }
+}
+
+impl std::fmt::Display for LineEdit {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&self.value)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crossterm::event::KeyEvent;
+
+    fn key(code: KeyCode) -> KeyEvent {
+        KeyEvent::new(code, KeyModifiers::NONE)
+    }
+
+    #[test]
+    fn edits_at_cursor() {
+        let mut edit = LineEdit::new("hllo");
+        assert_eq!(edit.cursor(), 4);
+        edit.handle_key(key(KeyCode::Home));
+        edit.handle_key(key(KeyCode::Right));
+        edit.handle_key(key(KeyCode::Char('e')));
+        assert_eq!(edit.as_str(), "hello");
+        assert_eq!(edit.cursor(), 2);
+        edit.handle_key(key(KeyCode::End));
+        edit.handle_key(key(KeyCode::Backspace));
+        assert_eq!(edit.as_str(), "hell");
+        edit.handle_key(key(KeyCode::Home));
+        edit.handle_key(key(KeyCode::Delete));
+        assert_eq!(edit.as_str(), "ell");
+    }
+
+    #[test]
+    fn multibyte_safe() {
+        let mut edit = LineEdit::new("метл");
+        edit.handle_key(key(KeyCode::Left));
+        edit.insert('а');
+        assert_eq!(edit.as_str(), "метал");
+        edit.handle_key(key(KeyCode::End));
+        edit.insert('л');
+        assert_eq!(edit.as_str(), "металл");
+    }
+}