Rework read_line_helper()

Author: yizhepku

src/engine.rs

@@ -51,11 +51,10 @@ use {
 // a POLL_WAIT of zero means that every single event is treated as soon as it
 // arrives. This doesn't allow for the possibility of more than 1 event
 // happening at the same time.
-const POLL_WAIT: u64 = 10;
-// Since a paste event is multiple Event::Key events happening at the same time, we specify
-// how many events should be in the crossterm_events vector before it is considered
-// a paste. 10 events in 10 milliseconds is conservative enough (unlikely somebody
-// will type more than 10 characters in 10 milliseconds)
+const POLL_WAIT: Duration = Duration::from_millis(100);
+// Since a paste event is multiple `Event::Key` events happening at the same
+// time, we specify how many events should be in the `crossterm_events` vector
+// before it is considered a paste. 10 events is conservative enough.
 const EVENTS_THRESHOLD: usize = 10;
 
 /// Determines if inputs should be used to extend the regular line buffer,
@@ -695,12 +694,7 @@ impl Reedline {
 
         self.repaint(prompt)?;
 
-        let mut crossterm_events: Vec<ReedlineRawEvent> = vec![];
-        let mut reedline_events: Vec<ReedlineEvent> = vec![];
-
         loop {
-            let mut paste_enter_state = false;
-
             #[cfg(feature = "external_printer")]
             if let Some(ref external_printer) = self.external_printer {
                 // get messages from printer as crlf separated "lines"
@@ -716,76 +710,74 @@ impl Reedline {
                 }
             }
 
-            let mut latest_resize = None;
-            loop {
-                // There could be multiple events queued up!
-                // pasting text, resizes, blocking this thread (e.g. during debugging)
-                // We should be able to handle all of them as quickly as possible without causing unnecessary output steps.
-                if !event::poll(Duration::from_millis(POLL_WAIT))? {
-                    break;
-                }
-
-                match event::read()? {
-                    Event::Resize(x, y) => {
-                        latest_resize = Some((x, y));
-                    }
-                    enter @ Event::Key(KeyEvent {
-                        code: KeyCode::Enter,
-                        modifiers: KeyModifiers::NONE,
-                        ..
-                    }) => {
-                        let enter = ReedlineRawEvent::convert_from(enter);
-                        if let Some(enter) = enter {
-                            crossterm_events.push(enter);
-                            // Break early to check if the input is complete and
-                            // can be send to the hosting application. If
-                            // multiple complete entries are submitted, events
-                            // are still in the crossterm queue for us to
-                            // process.
-                            paste_enter_state = crossterm_events.len() > EVENTS_THRESHOLD;
-                            break;
-                        }
-                    }
-                    x => {
-                        let raw_event = ReedlineRawEvent::convert_from(x);
-                        if let Some(evt) = raw_event {
-                            crossterm_events.push(evt);
-                        }
-                    }
+            // Helper function that returns true if the input is complete and
+            // can be sent to the hosting application.
+            fn completed(events: &[Event]) -> bool {
+                if let Some(event) = events.last() {
+                    matches!(
+                        event,
+                        Event::Key(KeyEvent {
+                            code: KeyCode::Enter,
+                            modifiers: KeyModifiers::NONE,
+                            ..
+                        })
+                    )
+                } else {
+                    false
                 }
             }
 
-            if let Some((x, y)) = latest_resize {
-                reedline_events.push(ReedlineEvent::Resize(x, y));
+            let mut events: Vec<Event> = vec![];
+
+            // Block until we receive an event.
+            events.push(crossterm::event::read()?);
+
+            // Receive all events in the queue without blocking. Will stop when
+            // a line of input is completed.
+            while !completed(&events) && event::poll(Duration::from_millis(0))? {
+                events.push(crossterm::event::read()?);
             }
 
-            // Accelerate pasted text by fusing `EditCommand`s
-            //
-            // (Text should only be `EditCommand::InsertChar`s)
-            let mut last_edit_commands = None;
-            for event in crossterm_events.drain(..) {
-                match (&mut last_edit_commands, self.edit_mode.parse_event(event)) {
-                    (None, ReedlineEvent::Edit(ec)) => {
-                        last_edit_commands = Some(ec);
-                    }
-                    (None, other_event) => {
-                        reedline_events.push(other_event);
-                    }
-                    (Some(ref mut last_ecs), ReedlineEvent::Edit(ec)) => {
-                        last_ecs.extend(ec);
-                    }
-                    (ref mut a @ Some(_), other_event) => {
-                        reedline_events.push(ReedlineEvent::Edit(a.take().unwrap()));
+            // If we believe there's text pasting or resizing going on, batch
+            // more events at the cost of a slight delay.
+            if events.len() > EVENTS_THRESHOLD
+                || events.iter().any(|e| matches!(e, Event::Resize(_, _)))
+            {
+                while !completed(&events) && event::poll(POLL_WAIT)? {
+                    events.push(crossterm::event::read()?);
+                }
+            }
 
-                        reedline_events.push(other_event);
+            // Convert `Event` into `ReedlineEvent`. Also, fuse consecutive
+            // `ReedlineEvent::EditCommand` into one. Also, if there're multiple
+            // `ReedlineEvent::Resize`, only keep the last one.
+            let mut reedline_events: Vec<ReedlineEvent> = vec![];
+            let mut edits = vec![];
+            let mut resize = None;
+            for event in events {
+                if let Some(event) = ReedlineRawEvent::convert_from(event) {
+                    match self.edit_mode.parse_event(event) {
+                        ReedlineEvent::Edit(edit) => edits.extend(edit),
+                        ReedlineEvent::Resize(x, y) => resize = Some((x, y)),
+                        event => {
+                            if !edits.is_empty() {
+                                reedline_events
+                                    .push(ReedlineEvent::Edit(std::mem::take(&mut edits)));
+                            }
+                            reedline_events.push(event);
+                        }
                     }
                 }
             }
-            if let Some(ec) = last_edit_commands {
-                reedline_events.push(ReedlineEvent::Edit(ec));
+            if !edits.is_empty() {
+                reedline_events.push(ReedlineEvent::Edit(edits));
+            }
+            if let Some((x, y)) = resize {
+                reedline_events.push(ReedlineEvent::Resize(x, y));
             }
 
-            for event in reedline_events.drain(..) {
+            // Handle reedline events.
+            for event in reedline_events {
                 match self.handle_event(prompt, event)? {
                     EventStatus::Exits(signal) => {
                         // Check if we are merely suspended (to process an ExecuteHostCommand event)
@@ -798,9 +790,7 @@ impl Reedline {
                         return Ok(signal);
                     }
                     EventStatus::Handled => {
-                        if !paste_enter_state {
-                            self.repaint(prompt)?;
-                        }
+                        self.repaint(prompt)?;
                     }
                     EventStatus::Inapplicable => {
                         // Nothing changed, no need to repaint