git.iko.soy/helix
on master help sign in
Refactor editor module to use state + keymap.
8119f1eBlaž Hrastnik
helix-term/src/editor.rs+54−31
compare with master
unifiedsplit
@@ -4,60 +4,81 @@ use crossterm::{
4 event::{self, read, Event, EventStream, KeyCode, KeyEvent},
4 event::{self, read, Event, EventStream, KeyCode, KeyEvent},
5 execute, queue, style,
5 execute, queue, style,
6 terminal::{self, disable_raw_mode, enable_raw_mode},
6 terminal::{self, disable_raw_mode, enable_raw_mode},
7− Result,
8};
7};
9use futures::{future::FutureExt, select, StreamExt};
8use futures::{future::FutureExt, select, StreamExt};
10use std::io::{self, stdout, Write};
9use std::io::{self, stdout, Write};
11use std::path::PathBuf;
10use std::path::PathBuf;
12use std::time::Duration;
11use std::time::Duration;
13
12
14−const HELP: &str = r#"
13+use anyhow::Error;
15− - Use q to quit
14+
16− - Move cursor with h, j, k, l
15+use crate::{keymap, Args};
17−"#;
16+use helix_core::{Buffer, State};
18
17
19pub struct Editor {
18pub struct Editor {
20− file: PathBuf,
19+ state: Option<State>,
21}
20}
22
21
23impl Editor {
22impl Editor {
23+ pub fn new(mut args: Args) -> Result<Self, Error> {
24+ let mut editor = Editor { state: None };
25+
26+ if let Some(file) = args.files.pop() {
27+ editor.open(file)?;
28+ }
29+
30+ Ok(editor)
31+ }
32+
33+ pub fn open(&mut self, path: PathBuf) -> Result<(), Error> {
34+ let buffer = Buffer::load(path)?;
35+ let state = State::new(buffer);
36+ self.state = Some(state);
37+ Ok(())
38+ }
39+
40+ fn render(&self) {
41+ // TODO:
42+ }
43+
24− pub async fn print_events() {
44+ pub async fn print_events(&mut self) {
25 let mut reader = EventStream::new();
45 let mut reader = EventStream::new();
46+ let keymap = keymap::default();
47+
48+ self.render();
49+
26 loop {
50 loop {
27 // Handle key events
51 // Handle key events
28 let mut event = reader.next().await;
52 let mut event = reader.next().await;
29 match event {
53 match event {
30− Some(Ok(x)) => {
54+ // TODO: handle resize events
31− if let Event::Key(KeyEvent {
55+ Some(Ok(Event::Key(KeyEvent {
32− code: KeyCode::Char(c),
56+ code: KeyCode::Char('q'),
33− ..
57+ ..
34− }) = x
58+ }))) => {
35− {
36− match c {
37− 'h' => execute!(io::stdout(), cursor::MoveLeft(1)).unwrap(),
38− 'j' => execute!(io::stdout(), cursor::MoveDown(1)).unwrap(),
39− 'k' => execute!(io::stdout(), cursor::MoveUp(1)).unwrap(),
40− 'l' => execute!(io::stdout(), cursor::MoveRight(1)).unwrap(),
41− 'q' => {
42− execute!(
43− io::stdout(),
44− style::ResetColor,
45− cursor::Show,
46− terminal::LeaveAlternateScreen
47− );
48− break;
59+ break;
49− }
60+ }
50− _ => println!("{:?}", x),
61+ Some(Ok(Event::Key(event))) => {
62+ // TODO: handle modes and sequences (`gg`)
63+ if let Some(command) = keymap.get(&event) {
64+ if let Some(state) = &mut self.state {
65+ // TODO: handle count other than 1
66+ command(state, 1);
67+ self.render();
51 }
68 }
52 }
69 }
53 }
70 }
71+ Some(Ok(_)) => {
72+ // unhandled event
73+ ()
74+ }
54 Some(Err(x)) => panic!(x),
75 Some(Err(x)) => panic!(x),
55 None => break,
76 None => break,
56 }
77 }
57 }
78 }
58 }
79 }
59
80
60− pub fn run() -> Result<()> {
81+ pub fn run(&mut self) -> Result<(), Error> {
61 enable_raw_mode()?;
82 enable_raw_mode()?;
62
83
63 let mut stdout = stdout();
84 let mut stdout = stdout();
@@ -81,7 +102,7 @@ impl Editor {
81 }
102 }
82
103
83 // No need to `run()`, now we can just block on the main future.
104 // No need to `run()`, now we can just block on the main future.
84− smol::block_on(Editor::print_events());
105+ smol::block_on(self.print_events());
85
106
86 // Send a shutdown signal.
107 // Send a shutdown signal.
87 drop(s);
108 drop(s);
@@ -93,6 +114,8 @@ impl Editor {
93 t.join().unwrap();
114 t.join().unwrap();
94 }
115 }
95
116
96− disable_raw_mode()
117+ disable_raw_mode()?;
118+
119+ Ok(())
97 }
120 }
98}
121}
helix-term/src/keymap.rs+1−1
@@ -94,7 +94,7 @@ macro_rules! hashmap {
94
94
95type Keymap = HashMap<Key, Command>;
95type Keymap = HashMap<Key, Command>;
96
96
97−fn default() -> Keymap {
97+pub fn default() -> Keymap {
98 hashmap!(
98 hashmap!(
99 Key {
99 Key {
100 code: KeyCode::Char('h'),
100 code: KeyCode::Char('h'),
helix-term/src/main.rs+2−1
@@ -22,7 +22,8 @@ fn main() -> Result<(), Error> {
22 let args: Args = argh::from_env();
22 let args: Args = argh::from_env();
23 println!("{:?}", args.files);
23 println!("{:?}", args.files);
24
24
25− editor::Editor::run()?;
25+ let mut editor = editor::Editor::new(args)?;
26+ editor.run();
26
27
27 Ok(())
28 Ok(())
28}
29}