nexedit 0.2.2

A vim-like text editor, with simple shortcuts.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

use crate::commands::Result;
use crate::errors::*;
use crate::input::Key;
use crate::models::application::modes::jump;
use crate::models::application::modes::JumpMode;
use crate::models::application::{Application, Mode};
use scribe::Workspace;
use std::mem;

pub fn match_tag(app: &mut Application) -> Result {
    let result = if let Mode::Jump(ref mut jump_mode) = app.mode {
        match jump_mode.input.len() {
            0 => return Ok(()), // Not enough data to match to a position.
            1 => {
                if jump_mode.first_phase {
                    jump_to_tag(jump_mode, &mut app.workspace)
                } else {
                    return Ok(()); // Not enough data to match to a position.
                }
            }
            _ => jump_to_tag(jump_mode, &mut app.workspace),
        }
    } else {
        bail!("Can't match jump tags outside of jump mode.");
    };
    switch_to_previous_mode(app);

    result
}

fn jump_to_tag(jump_mode: &mut JumpMode, workspace: &mut Workspace) -> Result {
    let position = jump_mode
        .map_tag(&jump_mode.input)
        .ok_or("Couldn't find a position for the specified tag")?;
    let buffer = workspace.current_buffer.as_mut().ok_or(BUFFER_MISSING)?;

    if !buffer.cursor.move_to(*position) {
        bail!(
            "Couldn't move to the specified tag's position ({:?})",
            position
        )
    }

    Ok(())
}

fn switch_to_previous_mode(app: &mut Application) {
    let old_mode = mem::replace(&mut app.mode, Mode::Normal);

    if let Mode::Jump(jump_mode) = old_mode {
        match jump_mode.select_mode {
            jump::SelectModeOptions::None => (),
            jump::SelectModeOptions::Select(select_mode) => {
                app.mode = Mode::Select(select_mode);
            }
            jump::SelectModeOptions::SelectLine(select_mode) => {
                app.mode = Mode::SelectLine(select_mode);
            }
        }
    }
}

pub fn push_search_char(app: &mut Application) -> Result {
    if let Some(ref key) = *app.view.last_key() {
        if let Mode::Jump(ref mut mode) = app.mode {
            match *key {
                Key::Char('f') => {
                    if mode.first_phase {
                        mode.first_phase = false;
                    } else {
                        mode.input.push('f');
                    }
                }
                Key::Char(c) => mode.input.push(c),
                _ => bail!("Last key press wasn't a character"),
            }
        } else {
            bail!("Can't push jump character outside of jump mode")
        }
    } else {
        bail!("View hasn't tracked a key press")
    }

    match_tag(app)
}