Merge pull request #88 from luisholanda/rework-event-parsing

Take msgv::Value by value in bridge::events

Cargo.toml

@@ -12,7 +12,7 @@ skribo = { git = "https://github.com/linebender/skribo" }
 lru = "0.4.3"
 skulpin = { git = "https://github.com/kethku/skulpin", branch = "winit_20" }
 derive-new = "0.5"
-rmpv = "0.4.2"
+rmpv = "0.4.4"
 rust-embed = { version = "5.2.0", features = ["debug-embed"] }
 image = "0.22.3"
 nvim-rs = { git = "https://github.com/KillTheMule/nvim-rs", features = [ "use_tokio" ] }

src/bridge/events.rs

@@ -1,5 +1,6 @@
 use std::error;
 use std::fmt;
+use std::convert::TryInto;
 
 use rmpv::Value;
 use skulpin::skia_safe::Color4f;
@@ -159,66 +160,56 @@ fn unpack_color(packed_color: u64) -> Color4f {
     }
 }
 
-fn parse_array(array_value: &Value) -> Result<&[Value]> {
+fn extract_values<Arr: AsMut<[Value]>>(values: Vec<Value>, mut arr: Arr) -> Result<Arr>
-    if let Value::Array(content) = array_value {
+{
-        Ok(&content[..])
+    let arr_ref = arr.as_mut();
+
+    if values.len() != arr_ref.len() {
+        Err(EventParseError::InvalidEventFormat)
     } else {
-        Err(EventParseError::InvalidArray(array_value.clone()))
+        for (i, val) in values.into_iter().enumerate() {
+            arr_ref[i] = val;
         }
-}
 
-fn parse_map(map_value: &Value) -> Result<&[(Value, Value)]> {
+        Ok(arr)
-    if let Value::Map(content) = map_value {
-        Ok(&content[..])
-    } else {
-        Err(EventParseError::InvalidMap(map_value.clone()))
     }
 }
 
-fn parse_string(string_value: &Value) -> Result<&str> {
+fn parse_array(array_value: Value) -> Result<Vec<Value>> {
-    if let Value::String(content) = string_value {
+    array_value.try_into().map_err(EventParseError::InvalidArray)
-        content.as_str().ok_or_else(|| EventParseError::InvalidString(string_value.clone()))
-    } else {
-        Err(EventParseError::InvalidString(string_value.clone()))
-    }
 }
 
-fn parse_u64(u64_value: &Value) -> Result<u64> {
+fn parse_map(map_value: Value) -> Result<Vec<(Value, Value)>> {
-    if let Value::Integer(content) = u64_value {
+    map_value.try_into().map_err(EventParseError::InvalidMap)
-        Ok(content.as_u64().ok_or_else(|| EventParseError::InvalidU64(u64_value.clone()))?)
-    } else {
-        Err(EventParseError::InvalidU64(u64_value.clone()))
-    }
 }
 
-fn parse_i64(i64_value: &Value) -> Result<i64> {
+fn parse_string(string_value: Value) -> Result<String> {
-    if let Value::Integer(content) = i64_value {
+    string_value.try_into().map_err(EventParseError::InvalidString)
-        Ok(content.as_i64().ok_or_else(|| EventParseError::InvalidI64(i64_value.clone()))?)
-    } else {
-        Err(EventParseError::InvalidI64(i64_value.clone()))
-    }
 }
 
-fn parse_bool(bool_value: &Value) -> Result<bool> {
+fn parse_u64(u64_value: Value) -> Result<u64> {
-    if let Value::Boolean(content) = bool_value {
+    u64_value.try_into().map_err(EventParseError::InvalidU64)
-        Ok(*content)
-    } else {
-        Err(EventParseError::InvalidBool(bool_value.clone()))
-    }
 }
 
-fn parse_set_title(set_title_arguments: &[Value]) -> Result<RedrawEvent> {
+fn parse_i64(i64_value: Value) -> Result<i64> {
-    if let [title] = set_title_arguments {
+    i64_value.try_into().map_err(EventParseError::InvalidI64)
+}
+
+fn parse_bool(bool_value: Value) -> Result<bool> {
+    bool_value.try_into().map_err(EventParseError::InvalidBool)
+}
+
+fn parse_set_title(set_title_arguments: Vec<Value>) -> Result<RedrawEvent> {
+    let [title] = extract_values(set_title_arguments, [Value::Nil])?;
+
     Ok(RedrawEvent::SetTitle {
-            title: parse_string(title)?.to_string()
+        title: parse_string(title)?
     })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
 }
 
-fn parse_mode_info_set(mode_info_set_arguments: &[Value]) -> Result<RedrawEvent> {
+fn parse_mode_info_set(mode_info_set_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [_cursor_style_enabled, mode_info] = mode_info_set_arguments {
+    let [_cursor_style_enabled, mode_info] = extract_values(mode_info_set_arguments, [Value::Nil, Value::Nil])?;
+
     let mode_info_values = parse_array(mode_info)?;
     let mut cursor_modes = Vec::with_capacity(mode_info_values.len());
 
@@ -227,9 +218,9 @@ fn parse_mode_info_set(mode_info_set_arguments: &[Value]) -> Result<RedrawEvent>
         let mut mode_info = CursorMode::default();
 
         for (name, value) in info_map {
-                match parse_string(name)? {
+            match parse_string(name)?.as_str() {
                 "cursor_shape" => {
-                        mode_info.shape = CursorShape::from_type_name(parse_string(value)?);
+                    mode_info.shape = CursorShape::from_type_name(&parse_string(value)?);
                 },
                 "cell_percentage" => {
                     mode_info.cell_percentage = Some(parse_u64(value)? as f32 / 100.0);
@@ -252,60 +243,56 @@ fn parse_mode_info_set(mode_info_set_arguments: &[Value]) -> Result<RedrawEvent>
 
         cursor_modes.push(mode_info);
     }
+
     Ok(RedrawEvent::ModeInfoSet {
         cursor_modes
     })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
 }
 
-fn parse_option_set(option_set_arguments: &[Value]) -> Result<RedrawEvent> {
+fn parse_option_set(option_set_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [name, value] = option_set_arguments {
+    let [name, value] = extract_values(option_set_arguments, [Value::Nil, Value::Nil])?;
+
+    let name = parse_string(name)?;
+
     Ok(RedrawEvent::OptionSet {
-            gui_option: match parse_string(name)? {
+        gui_option: match name.as_str() {
             "arabicshape" => GuiOption::AribicShape(parse_bool(value)?),
-                "ambiwidth" => GuiOption::AmbiWidth(parse_string(value)?.to_string()),
+            "ambiwidth" => GuiOption::AmbiWidth(parse_string(value)?),
             "emoji" => GuiOption::Emoji(parse_bool(value)?),
-                "guifont" => GuiOption::GuiFont(parse_string(value)?.to_string()),
+            "guifont" => GuiOption::GuiFont(parse_string(value)?),
-                "guifontset" => GuiOption::GuiFontSet(parse_string(value)?.to_string()),
+            "guifontset" => GuiOption::GuiFontSet(parse_string(value)?),
-                "guifontwide" => GuiOption::GuiFontWide(parse_string(value)?.to_string()),
+            "guifontwide" => GuiOption::GuiFontWide(parse_string(value)?),
             "linespace" => GuiOption::LineSpace(parse_u64(value)?),
             "pumblend" => GuiOption::Pumblend(parse_u64(value)?),
             "showtabline" => GuiOption::ShowTabLine(parse_u64(value)?),
             "termguicolors" => GuiOption::TermGuiColors(parse_bool(value)?),
-                unknown_option => GuiOption::Unknown(unknown_option.to_string(), value.clone())
+            _ => GuiOption::Unknown(name, value)
         }
     })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
 }
 
-fn parse_mode_change(mode_change_arguments: &[Value]) -> Result<RedrawEvent> {
+fn parse_mode_change(mode_change_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [_mode, mode_index] = mode_change_arguments {
+    let [_mode, mode_index] = extract_values(mode_change_arguments, [Value::Nil, Value::Nil])?;
+
     Ok(RedrawEvent::ModeChange {
         mode_index: parse_u64(mode_index)?
     })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
 }
 
-fn parse_grid_resize(grid_resize_arguments: &[Value]) -> Result<RedrawEvent> {
+fn parse_grid_resize(grid_resize_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [grid_id, width, height] = grid_resize_arguments {
+    let [grid_id, width, height] = extract_values(grid_resize_arguments, [Value::Nil, Value::Nil, Value::Nil])?;
+
     Ok(RedrawEvent::Resize {
-            grid: parse_u64(grid_id)?, width: parse_u64(width)?, height: parse_u64(height)?
+        grid: parse_u64(grid_id)?,
+        width: parse_u64(width)?,
+        height: parse_u64(height)?
     })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
 }
 
-fn parse_default_colors(default_colors_arguments: &[Value]) -> Result<RedrawEvent> {
+fn parse_default_colors(default_colors_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [
+    let values = [Value::Nil, Value::Nil, Value::Nil, Value::Nil, Value::Nil];
-        foreground, background, special, _term_foreground, _term_background
+    let [foreground, background, special, _term_foreground, _term_background] = extract_values(default_colors_arguments, values)?;
-    ] = default_colors_arguments {
+
     Ok(RedrawEvent::DefaultColorsSet {
         colors: Colors {
             foreground: Some(unpack_color(parse_u64(foreground)?)),
@@ -313,13 +300,11 @@ fn parse_default_colors(default_colors_arguments: &[Value]) -> Result<RedrawEven
             special: Some(unpack_color(parse_u64(special)?)),
         }
     })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
 }
 
-fn parse_style(style_map: &Value) -> Result<Style> {
+fn parse_style(style_map: Value) -> Result<Style> {
-    if let Value::Map(attributes) = style_map {
+    let attributes = parse_map(style_map)?;
+
     let mut style = Style::new(Colors::new(None, None, None));
 
     for attribute in attributes {
@@ -328,12 +313,12 @@ fn parse_style(style_map: &Value) -> Result<Style> {
                 ("foreground", Value::Integer(packed_color)) => style.colors.foreground = Some(unpack_color(packed_color.as_u64().unwrap())),
                 ("background", Value::Integer(packed_color)) => style.colors.background = Some(unpack_color(packed_color.as_u64().unwrap())),
                 ("special", Value::Integer(packed_color)) => style.colors.special = Some(unpack_color(packed_color.as_u64().unwrap())),
-                    ("reverse", Value::Boolean(reverse)) => style.reverse = *reverse,
+                ("reverse", Value::Boolean(reverse)) => style.reverse = reverse,
-                    ("italic", Value::Boolean(italic)) => style.italic = *italic,
+                ("italic", Value::Boolean(italic)) => style.italic = italic,
-                    ("bold", Value::Boolean(bold)) => style.bold = *bold,
+                ("bold", Value::Boolean(bold)) => style.bold = bold,
-                    ("strikethrough", Value::Boolean(strikethrough)) => style.strikethrough = *strikethrough,
+                ("strikethrough", Value::Boolean(strikethrough)) => style.strikethrough = strikethrough,
-                    ("underline", Value::Boolean(underline)) => style.underline = *underline,
+                ("underline", Value::Boolean(underline)) => style.underline = underline,
-                    ("undercurl", Value::Boolean(undercurl)) => style.undercurl = *undercurl,
+                ("undercurl", Value::Boolean(undercurl)) => style.undercurl = undercurl,
                 ("blend", Value::Integer(blend)) => style.blend = blend.as_u64().unwrap() as u8,
                 _ => println!("Ignored style attribute: {}", name)
             }
@@ -343,80 +328,83 @@ fn parse_style(style_map: &Value) -> Result<Style> {
     }
 
     Ok(style)
-    } else {
-        Err(EventParseError::InvalidMap(style_map.clone()))
-    }
 }
 
-fn parse_hl_attr_define(hl_attr_define_arguments: &[Value]) -> Result<RedrawEvent> {
+fn parse_hl_attr_define(hl_attr_define_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [
+    let values = [Value::Nil, Value::Nil, Value::Nil, Value::Nil];
-        id, attributes, _terminal_attributes, _info
+    let [id, attributes, _terminal_attributes, _info] = extract_values(hl_attr_define_arguments, values)?;
-    ] = hl_attr_define_arguments {
+
     let style = parse_style(attributes)?;
     Ok(RedrawEvent::HighlightAttributesDefine { id: parse_u64(id)?, style })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
 }
 
-fn parse_grid_line_cell(grid_line_cell: &Value) -> Result<GridLineCell> {
+fn parse_grid_line_cell(grid_line_cell: Value) -> Result<GridLineCell> {
-    let cell_contents = parse_array(grid_line_cell)?;
+    fn take_value(val: &mut Value) -> Value {
-    let text_value = cell_contents.get(0).ok_or(EventParseError::InvalidEventFormat)?;
+        std::mem::replace(val, Value::Nil)
+    }
+
+    let mut cell_contents = parse_array(grid_line_cell)?;
+
+    let text_value = cell_contents.first_mut()
+        .map(|v| take_value(v))
+        .ok_or(EventParseError::InvalidEventFormat)?;
+
+    let highlight_id = cell_contents.get_mut(1).map(|v| take_value(v)).map(parse_u64).transpose()?;
+    let repeat = cell_contents.get_mut(2).map(|v| take_value(v)).map(parse_u64).transpose()?;
+
     Ok(GridLineCell {
-        text: parse_string(text_value)?.to_string(),
+        text: parse_string(text_value)?,
-        highlight_id: cell_contents.get(1).map(parse_u64).transpose()?,
+        highlight_id,
-        repeat: cell_contents.get(2).map(parse_u64).transpose()?
+        repeat
     })
 }
 
-fn parse_grid_line(grid_line_arguments: &[Value]) -> Result<RedrawEvent> {
+fn parse_grid_line(grid_line_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [grid_id, row, column_start, cells] = grid_line_arguments {
+    let values = [Value::Nil, Value::Nil, Value::Nil, Value::Nil];
+    let [grid_id, row, column_start, cells] = extract_values(grid_line_arguments, values)?;
+
     Ok(RedrawEvent::GridLine {
         grid: parse_u64(grid_id)?,
-            row: parse_u64(row)?, column_start: parse_u64(column_start)?,
+        row: parse_u64(row)?,
+        column_start: parse_u64(column_start)?,
         cells: parse_array(cells)?
             .into_iter()
             .map(parse_grid_line_cell)
             .collect::<Result<Vec<GridLineCell>>>()?
     })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
 }
 
-fn parse_clear(clear_arguments: &[Value]) -> Result<RedrawEvent> {
+fn parse_clear(clear_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [grid_id] = clear_arguments {
+    let [grid_id] = extract_values(clear_arguments, [Value::Nil])?;
+
     Ok(RedrawEvent::Clear { grid: parse_u64(grid_id)? })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
 }
 
-fn parse_cursor_goto(cursor_goto_arguments: &[Value]) -> Result<RedrawEvent> {
+fn parse_cursor_goto(cursor_goto_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [grid_id, column, row] = cursor_goto_arguments {
+    let [grid_id, column, row] = extract_values(cursor_goto_arguments, [Value::Nil, Value::Nil, Value::Nil])?;
+
     Ok(RedrawEvent::CursorGoto {
-            grid: parse_u64(grid_id)?, row: parse_u64(row)?, column: parse_u64(column)?
+        grid: parse_u64(grid_id)?,
+        row: parse_u64(row)?,
+        column: parse_u64(column)?
     })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
 }
 
-fn parse_grid_scroll(grid_scroll_arguments: &[Value]) -> Result<RedrawEvent> {
+fn parse_grid_scroll(grid_scroll_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [grid_id, top, bottom, left, right, rows, columns] = grid_scroll_arguments {
+    let values = [Value::Nil, Value::Nil, Value::Nil, Value::Nil, Value::Nil, Value::Nil, Value::Nil];
+    let [grid_id, top, bottom, left, right, rows, columns] = extract_values(grid_scroll_arguments, values)?;
     Ok(RedrawEvent::Scroll {
         grid: parse_u64(grid_id)?,
         top: parse_u64(top)?, bottom: parse_u64(bottom)?,
         left: parse_u64(left)?, right: parse_u64(right)?,
         rows: parse_i64(rows)?, columns: parse_i64(columns)?
     })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
 }
 
-fn parse_win_pos(win_pos_arguments: &[Value]) -> Result<RedrawEvent> {
+fn parse_win_pos(win_pos_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [grid, window, start_row, start_column, width, height] = win_pos_arguments {
+    let values = [Value::Nil, Value::Nil, Value::Nil, Value::Nil, Value::Nil, Value::Nil];
+    let [grid, window, start_row, start_column, width, height] = extract_values(win_pos_arguments, values)?;
+
     Ok(RedrawEvent::WindowPosition {
         grid: parse_u64(grid)?,
         window: parse_u64(window)?,
@@ -425,23 +413,23 @@ fn parse_win_pos(win_pos_arguments: &[Value]) -> Result<RedrawEvent> {
         width: parse_u64(width)?,
         height: parse_u64(height)?
     })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
 }
 
-fn parse_window_anchor(value: &Value) -> Result<WindowAnchor> {
+fn parse_window_anchor(value: Value) -> Result<WindowAnchor> {
-    match parse_string(value).ok() {
+    let value_str = parse_string(value)?;
-        Some("NW") => Ok(WindowAnchor::NorthWest),
+    match value_str.as_str() {
-        Some("NE") => Ok(WindowAnchor::NorthEast),
+        "NW" => Ok(WindowAnchor::NorthWest),
-        Some("SW") => Ok(WindowAnchor::SouthWest),
+        "NE" => Ok(WindowAnchor::NorthEast),
-        Some("SE") => Ok(WindowAnchor::SouthEast),
+        "SW" => Ok(WindowAnchor::SouthWest),
-        _ => Err(EventParseError::InvalidWindowAnchor(value.clone()))
+        "SE" => Ok(WindowAnchor::SouthEast),
+        _ => Err(EventParseError::InvalidWindowAnchor(value_str.into()))
     }
 }
 
-fn parse_win_float_pos(win_float_pos_arguments: &[Value]) -> Result<RedrawEvent> {
+fn parse_win_float_pos(win_float_pos_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [grid, window, anchor, anchor_grid, anchor_row, anchor_column, focusable] = win_float_pos_arguments {
+    let values = [Value::Nil, Value::Nil, Value::Nil, Value::Nil, Value::Nil, Value::Nil, Value::Nil];
+    let [grid, window, anchor, anchor_grid, anchor_row, anchor_column, focusable] = extract_values(win_float_pos_arguments, values)?;
+
     Ok(RedrawEvent::WindowFloatPosition {
         grid: parse_u64(grid)?,
         window: parse_u64(window)?,
@@ -451,202 +439,171 @@ fn parse_win_float_pos(win_float_pos_arguments: &[Value]) -> Result<RedrawEvent>
         anchor_column: parse_u64(anchor_column)?,
         focusable: parse_bool(focusable)?
     })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
 }
 
-fn parse_win_external_pos(win_external_pos_arguments: &[Value]) -> Result<RedrawEvent> {
+fn parse_win_external_pos(win_external_pos_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [grid, window] = win_external_pos_arguments {
+    let [grid, window] = extract_values(win_external_pos_arguments, [Value::Nil, Value::Nil])?;
+
     Ok(RedrawEvent::WindowExternalPosition {
         grid: parse_u64(grid)?,
         window: parse_u64(window)?
     })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
 }
 
-fn parse_win_hide(win_hide_arguments: &[Value]) -> Result<RedrawEvent> {
+fn parse_win_hide(win_hide_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [grid] = win_hide_arguments {
+    let [grid] = extract_values(win_hide_arguments, [Value::Nil])?;
+
     Ok(RedrawEvent::WindowHide {
         grid: parse_u64(grid)?
     })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
 }
 
-fn parse_win_close(win_close_arguments: &[Value]) -> Result<RedrawEvent> {
+fn parse_win_close(win_close_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [grid] = win_close_arguments {
+    let [grid] = extract_values(win_close_arguments, [Value::Nil])?;
+
     Ok(RedrawEvent::WindowClose {
         grid: parse_u64(grid)?
     })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
 }
 
-fn parse_msg_set_pos(msg_set_pos_arguments: &[Value]) -> Result<RedrawEvent> {
+fn parse_msg_set_pos(msg_set_pos_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [grid, row, scrolled, separator_character] = msg_set_pos_arguments {
+    let values = [Value::Nil, Value::Nil, Value::Nil, Value::Nil];
+    let [grid, row, scrolled, separator_character] = extract_values(msg_set_pos_arguments, values)?;
+
     Ok(RedrawEvent::MessageSetPosition {
         grid: parse_u64(grid)?,
         row: parse_u64(row)?,
         scrolled: parse_bool(scrolled)?,
-            separator_character: parse_string(separator_character)?.to_string()
+        separator_character: parse_string(separator_character)?
     })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
 }
 
-fn parse_styled_content(line: &Value) -> Result<StyledContent> {
+fn parse_styled_content(line: Value) -> Result<StyledContent> {
-    parse_array(line)?.iter().map(|tuple| {
+    parse_array(line)?.into_iter().map(|tuple| {
-        if let [style_id, text] = parse_array(tuple)? {
+        let [style_id, text] = extract_values(parse_array(tuple)?, [Value::Nil, Value::Nil])?;
-            Ok((parse_u64(style_id)?, parse_string(text)?.to_string()))
+
-        } else {
+        Ok((parse_u64(style_id)?, parse_string(text)?))
-            Err(EventParseError::InvalidEventFormat)
-        }
     }).collect()
 }
 
-fn parse_cmdline_show(cmdline_show_arguments: &[Value]) -> Result<RedrawEvent> {
+fn parse_cmdline_show(cmdline_show_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [content, position, first_character, prompt, indent, level] = cmdline_show_arguments {
+    let values = [Value::Nil, Value::Nil, Value::Nil, Value::Nil, Value::Nil, Value::Nil];
+    let [content, position, first_character, prompt, indent, level] = extract_values(cmdline_show_arguments, values)?;
+
     Ok(RedrawEvent::CommandLineShow {
         content: parse_styled_content(content)?,
         position: parse_u64(position)?,
-            first_character: parse_string(first_character)?.to_string(),
+        first_character: parse_string(first_character)?,
-            prompt: parse_string(prompt)?.to_string(),
+        prompt: parse_string(prompt)?,
         indent: parse_u64(indent)?,
         level: parse_u64(level)?
     })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
 }
 
-fn parse_cmdline_pos(cmdline_pos_arguments: &[Value]) -> Result<RedrawEvent> {
+fn parse_cmdline_pos(cmdline_pos_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [position, level] = cmdline_pos_arguments {
+    let [position, level] = extract_values(cmdline_pos_arguments, [Value::Nil, Value::Nil])?;
+
     Ok(RedrawEvent::CommandLinePosition {
         position: parse_u64(position)?,
         level: parse_u64(level)?
     })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
 }
 
-fn parse_cmdline_special_char(cmdline_special_char_arguments: &[Value]) -> Result<RedrawEvent> {
+fn parse_cmdline_special_char(cmdline_special_char_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [character, shift, level] = cmdline_special_char_arguments {
+    let [character, shift, level] = extract_values(cmdline_special_char_arguments, [Value::Nil, Value::Nil, Value::Nil])?;
+
     Ok(RedrawEvent::CommandLineSpecialCharacter {
-            character: parse_string(character)?.to_string(),
+        character: parse_string(character)?,
         shift: parse_bool(shift)?,
         level: parse_u64(level)?
     })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
 }
 
-fn parse_cmdline_block_show(cmdline_block_show_arguments: &[Value]) -> Result<RedrawEvent> {
+fn parse_cmdline_block_show(cmdline_block_show_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [lines] = cmdline_block_show_arguments {
+    let [lines] = extract_values(cmdline_block_show_arguments, [Value::Nil])?;
+
     Ok(RedrawEvent::CommandLineBlockShow {
         lines: parse_array(lines)?
-                .iter()
+            .into_iter()
             .map(parse_styled_content)
             .collect::<Result<_>>()?
     })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
 }
 
-fn parse_cmdline_block_append(cmdline_block_append_arguments: &[Value]) -> Result<RedrawEvent> {
+fn parse_cmdline_block_append(cmdline_block_append_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [line] = cmdline_block_append_arguments {
+    let [line] = extract_values(cmdline_block_append_arguments, [Value::Nil])?;
+
     Ok(RedrawEvent::CommandLineBlockAppend {
         line: parse_styled_content(line)?
     })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
 }
 
-fn parse_msg_show(msg_show_arguments: &[Value]) -> Result<RedrawEvent> {
+fn parse_msg_show(msg_show_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [kind, content, replace_last] = msg_show_arguments {
+    let [kind, content, replace_last] = extract_values(msg_show_arguments, [Value::Nil, Value::Nil, Value::Nil])?;
+
     Ok(RedrawEvent::MessageShow {
-            kind: MessageKind::parse(parse_string(kind)?),
+        kind: MessageKind::parse(&parse_string(kind)?),
         content: parse_styled_content(content)?,
         replace_last: parse_bool(replace_last)?
     })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
 }
 
-fn parse_msg_showmode(msg_showmode_arguments: &[Value]) -> Result<RedrawEvent> {
+fn parse_msg_showmode(msg_showmode_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [content] = msg_showmode_arguments {
+    let [content] = extract_values(msg_showmode_arguments, [Value::Nil])?;
+
     Ok(RedrawEvent::MessageShowMode {
         content: parse_styled_content(content)?,
     })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
 }
 
-fn parse_msg_showcmd(msg_showcmd_arguments: &[Value]) -> Result<RedrawEvent> {
+fn parse_msg_showcmd(msg_showcmd_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [content] = msg_showcmd_arguments {
+    let [content] = extract_values(msg_showcmd_arguments, [Value::Nil])?;
+
     Ok(RedrawEvent::MessageShowCommand {
         content: parse_styled_content(content)?,
     })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
 }
 
-fn parse_msg_ruler(msg_ruler_arguments: &[Value]) -> Result<RedrawEvent> {
+fn parse_msg_ruler(msg_ruler_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [content] = msg_ruler_arguments {
+    let [content] = extract_values(msg_ruler_arguments, [Value::Nil])?;
+
     Ok(RedrawEvent::MessageRuler {
         content: parse_styled_content(content)?,
     })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
 }
 
-fn parse_msg_history_entry(entry: &Value) -> Result<(MessageKind, StyledContent)> {
+fn parse_msg_history_entry(entry: Value) -> Result<(MessageKind, StyledContent)> {
-    if let [kind, content] = parse_array(entry)?{
+    let [kind, content] = extract_values(parse_array(entry)?, [Value::Nil, Value::Nil])?;
+
     Ok((
-            MessageKind::parse(parse_string(kind)?),
+        MessageKind::parse(&parse_string(kind)?),
         parse_styled_content(content)?
     ))
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
 }
 
-fn parse_msg_history_show(msg_history_show_arguments: &[Value]) -> Result<RedrawEvent> {
+fn parse_msg_history_show(msg_history_show_arguments: Vec<Value>) -> Result<RedrawEvent> {
-    if let [entries] = msg_history_show_arguments {
+    let [entries] = extract_values(msg_history_show_arguments, [Value::Nil])?;
+
     Ok(RedrawEvent::MessageHistoryShow {
         entries: parse_array(entries)?
-                .iter()
+            .into_iter()
             .map(parse_msg_history_entry)
             .collect::<Result<_>>()?
     })
-    } else {
-        Err(EventParseError::InvalidEventFormat)
-    }
 }
 
-pub fn parse_redraw_event(event_value: &Value) -> Result<Vec<RedrawEvent>> {
+pub fn parse_redraw_event(event_value: Value) -> Result<Vec<RedrawEvent>> {
-    let event_contents = parse_array(event_value)?;
+    let mut event_contents = parse_array(event_value)?.into_iter();
-    let name_value = event_contents.get(0).ok_or(EventParseError::InvalidEventFormat)?;
+    let event_name = event_contents.next()
-    let event_name = parse_string(name_value)?;
+        .ok_or(EventParseError::InvalidEventFormat)
+        .and_then(parse_string)?;
+
     let events = event_contents;
     let mut parsed_events = Vec::with_capacity(events.len());
 
-    for event in &events[1..] {
+    for event in events {
-        let event_parameters = parse_array(&event)?;
+        let event_parameters = parse_array(event)?;
-        let possible_parsed_event = match event_name {
+        let possible_parsed_event = match event_name.as_str() {
             "set_title" => Some(parse_set_title(event_parameters)?),
             "set_icon" => None, // Ignore set icon for now
             "mode_info_set" => Some(parse_mode_info_set(event_parameters)?),
@@ -692,9 +649,10 @@ pub fn parse_redraw_event(event_value: &Value) -> Result<Vec<RedrawEvent>> {
     Ok(parsed_events)
 }
 
-pub(in super) fn parse_neovim_event(event_name: &str, arguments: &[Value]) -> Result<Vec<RedrawEvent>> {
+pub(in super) fn parse_neovim_event(event_name: &str, arguments: Vec<Value>) -> Result<Vec<RedrawEvent>> {
-    let mut resulting_events = Vec::with_capacity(arguments.len());
+    let mut resulting_events = Vec::new();
     if event_name == "redraw" {
+        resulting_events.reserve(arguments.len());
         for event in arguments {
             resulting_events.append(&mut parse_redraw_event(event)?);
         }

src/bridge/handler.rs

@@ -44,7 +44,7 @@ impl Handler for NeovimHandler {
 
     async fn handle_notify(&self, event_name: String, arguments: Vec<Value>, _neovim: Neovim<Compat<ChildStdin>>) {
         trace!("Neovim notification: {:?}", &event_name);
-        let parsed_events = parse_neovim_event(&event_name, &arguments)
+        let parsed_events = parse_neovim_event(&event_name, arguments)
             .unwrap_or_explained_panic("Could not parse event from neovim");
         for event in parsed_events {
             self.handle_redraw_event(event);