Sublime-like changes

.gitignore

@@ -4,6 +4,7 @@
 *.err
 *.orig
 *.log
+*.log.rpc
 *.rej
 *.swo
 *.swp

Cargo.toml

@@ -2,6 +2,7 @@
 authors = ["Corentin Henry <[email protected]>"]
 name = "xi-term"
 version = "0.1.0"
+edition = "2018"
 
 [dependencies]
 clap = "2.33.0"
@@ -14,3 +15,6 @@ tokio = "0.1.21"
 xdg = "2.2.0"
 indexmap = "1.0.2"
 xrl = "0.0.7"
+serde = { version = "1.0.93", features = ["derive"] }
+serde_json = "1.0.39"
+json5 = "0.2.4"

src/core/cmd.rs

@@ -4,8 +4,62 @@
 use xrl::ViewId;
 
 use std::str::FromStr;
+use serde::{Deserialize, Serialize};
 
-#[derive(Debug)]
+#[allow(non_camel_case_types)]
+#[derive(Debug, Deserialize, Serialize, PartialEq, Clone)]
+pub enum RelativeMoveDistance {
+    /// Move only one character
+    characters,
+    /// Move a line
+    lines,
+    /// Move to new word
+    words,
+    /// Move to end of word
+    word_ends,
+    /// Move to new subword
+    subwords,
+    /// Move to end of subword
+    subword_ends,
+    /// Move a page
+    pages,
+}
+
+#[allow(non_camel_case_types)]
+#[derive(Debug, Deserialize, Serialize, PartialEq, Clone)]
+pub struct RelativeMove {
+    pub by: RelativeMoveDistance,
+    pub forward: bool,
+    #[serde(default)]
+    pub extend: bool
+}
+
+#[allow(non_camel_case_types)]
+#[derive(Debug, Deserialize, Serialize, PartialEq, Clone)]
+pub enum AbsoluteMovePoint {
+    /// Beginning of file
+    bof,
+    /// End of file
+    eof,
+    /// Beginning of line
+    bol,
+    /// End of line
+    eol,
+    /// Enclosing brackets
+    brackets,
+    /// Line number
+    line(u64)
+}
+
+#[allow(non_camel_case_types)]
+#[derive(Debug, Deserialize, Serialize, PartialEq, Clone)]
+pub struct AbsoluteMove {
+    pub to: AbsoluteMovePoint,
+    #[serde(default)]
+    pub extend: bool
+}
+
+#[derive(Debug, PartialEq, Clone)]
 pub enum Command {
     /// Close the CommandPrompt.
     Cancel,
@@ -23,22 +77,16 @@ pub enum Command {
     NextBuffer,
     /// Cycle to the previous buffer.
     PrevBuffer,
-    /// Move cursor left.
-    MoveLeft,
-    /// Move cursor right.
-    MoveRight,
-    /// Move cursor up.
-    MoveUp,
-    /// Move cursor down.
-    MoveDown,
-    /// Page down
-    PageDown,
-    /// Page up
-    PageUp,
-    /// Change the syntax theme.
+    // Relative move like line up/down, page up/down, left, right, word left, ..
+    RelativeMove(RelativeMove),
+    // Relative move like line ending/beginning, file ending/beginning, line-number, ...
+    AbsoluteMove(AbsoluteMove),
+
     SetTheme(String),
     /// Toggle displaying line numbers.
     ToggleLineNumbers,
+    /// Open prompt for user-input
+    OpenPrompt,
 }
 
 #[derive(Debug)]
@@ -67,18 +115,79 @@ impl FromStr for Command {
     fn from_str(s: &str) -> Result<Command, Self::Err> {
         match &s[..] {
             "s" | "save" => Ok(Command::Save(None)),
-            "q" | "quit" => Ok(Command::Quit),
-            "b" | "back" => Ok(Command::Back),
-            "d" | "delete" => Ok(Command::Delete),
-            "bn" | "next-buffer" => Ok(Command::NextBuffer),
-            "bp" | "prev-buffer" => Ok(Command::PrevBuffer),
-            "pd" | "page-down" => Ok(Command::PageDown),
-            "pu" | "page-up" => Ok(Command::PageUp),
-            "ml" | "move-left" => Ok(Command::MoveLeft),
-            "mr" | "move-right" => Ok(Command::MoveRight),
-            "mu" | "move-up" => Ok(Command::MoveUp),
-            "md" | "move-down" => Ok(Command::MoveDown),
+            "q" | "quit" | "exit" => Ok(Command::Quit),
+            "b" | "back" | "left_delete" => Ok(Command::Back),
+            "d" | "delete" | "right_delete" => Ok(Command::Delete),
+            "bn" | "next-buffer" | "next_view" => Ok(Command::NextBuffer),
+            "bp" | "prev-buffer" | "prev_view" => Ok(Command::PrevBuffer),
+            "md" | "move-down" => Ok(Command::RelativeMove(
+                                                    RelativeMove{
+                                                                by: RelativeMoveDistance::lines, 
+                                                                forward: true, 
+                                                                extend: false
+                                                                }
+                                                   )),
+            "mu" | "move-up" => Ok(Command::RelativeMove(
+                                                    RelativeMove{
+                                                                by: RelativeMoveDistance::lines, 
+                                                                forward: false, 
+                                                                extend: false
+                                                                }
+                                                   )),
+            "mr" | "move-right" => Ok(Command::RelativeMove(
+                                                    RelativeMove{
+                                                                by: RelativeMoveDistance::characters, 
+                                                                forward: true, 
+                                                                extend: false
+                                                                }
+                                                   )),
+            "ml" | "move-left" => Ok(Command::RelativeMove(
+                                                    RelativeMove{
+                                                                by: RelativeMoveDistance::characters, 
+                                                                forward: false, 
+                                                                extend: false
+                                                                }
+                                                   )),
+            "pd" | "page-down" => Ok(Command::RelativeMove(
+                                                    RelativeMove{
+                                                                by: RelativeMoveDistance::pages, 
+                                                                forward: true, 
+                                                                extend: false
+                                                                }
+                                                   )),
+            "pu" | "page-up" => Ok(Command::RelativeMove(
+                                                    RelativeMove{
+                                                                by: RelativeMoveDistance::pages, 
+                                                                forward: false, 
+                                                                extend: false
+                                                                }
+                                                   )),
+            "bof" | "beginning-of-file" => Ok(Command::AbsoluteMove(
+                                                    AbsoluteMove{
+                                                                to: AbsoluteMovePoint::bof,
+                                                                extend: false
+                                                                }
+                                                   )),
+            "eof" | "end-of-file" => Ok(Command::AbsoluteMove(
+                                                    AbsoluteMove{
+                                                                to: AbsoluteMovePoint::eof,
+                                                                extend: false
+                                                                }
+                                                   )),
+            "bol" | "beginning-of-line" => Ok(Command::AbsoluteMove(
+                                                    AbsoluteMove{
+                                                                to: AbsoluteMovePoint::bol,
+                                                                extend: false
+                                                                }
+                                                   )),
+            "eol" | "end-of-line" => Ok(Command::AbsoluteMove(
+                                                    AbsoluteMove{
+                                                                to: AbsoluteMovePoint::eol,
+                                                                extend: false
+                                                                }
+                                                   )),
             "ln" | "line-numbers" => Ok(Command::ToggleLineNumbers),
+            "op" | "open-prompt" | "show_overlay" => Ok(Command::OpenPrompt),
             command => {
                 let mut parts: Vec<&str> = command.split(' ').collect();
 

src/core/config.rs

@@ -0,0 +1,136 @@
+use crate::core::{Command, RelativeMove, AbsoluteMove};
+use termion::event::{Event, Key};
+
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+use std::path::{Path, PathBuf};
+use std::fs;
+use std::collections::HashMap;
+
+use std::str::FromStr;
+
+pub type Keymap = HashMap<Event, Command>;
+
+#[derive(Debug, Serialize, Deserialize)]
+struct Keybinding {
+    keys: Vec<String>,
+    command: String,
+    // For now, unstructured value
+    args: Option<Value>,
+    context: Option<Value>,
+}
+
+#[derive(Clone)]
+pub struct KeybindingConfig {
+    pub keymap: Keymap,
+    pub config_path: PathBuf
+}
+
+impl KeybindingConfig {
+    pub fn parse(config_path: &Path) -> Result<KeybindingConfig, Box<dyn std::error::Error + Sync + Send + 'static>> {
+        let entries = fs::read_to_string(config_path)?;
+        // Read the JSON contents of the file as an instance of `User`.
+        let bindings: Vec<Keybinding> = json5::from_str(&entries)?;
+        error!("Bindings parsed!");
+
+        let mut keymap = Keymap::new();
+        let mut found_cmds = Vec::new();
+        for binding in bindings {
+            let cmd = match binding.command.as_ref() {
+                "move"    => {
+                    let args = binding.args.ok_or("move binding incomplete! Missing \"args\"")?;
+                    let cmd : RelativeMove = serde_json::from_value(args)?;
+                    Command::RelativeMove(cmd)
+                },
+                "move_to" => {
+                    let args = binding.args.ok_or("move_to binding incomplete! Missing \"args\"")?;
+                    let cmd : AbsoluteMove = serde_json::from_value(args)?;
+                    Command::AbsoluteMove(cmd)
+                },
+                x =>  match Command::from_str(x) {
+                          Ok(cmd) => cmd,
+                          // unimplemented command for now
+                          Err(_) => continue,
+                }
+            };
+            if found_cmds.contains(&cmd) {
+                continue;
+            }
+            if let Some(binding) = KeybindingConfig::parse_keys(&binding.keys) {
+                error!("{:?} = {:?}", cmd, binding);
+                keymap.insert(binding, cmd.clone());
+                found_cmds.push(cmd);
+            } else {
+                warn!("Skipping failed binding");
+                continue;
+            }
+        }
+
+        Ok(KeybindingConfig{keymap: keymap, config_path: config_path.to_owned()})
+    }
+
+    fn parse_keys(keys: &Vec<String>) -> Option<Event> {
+        if keys.len() != 1 {
+            return None;
+        }
+
+        let key = &keys[0];
+        match key.as_ref() {
+            "enter" => Some(Event::Key(Key::Char('\n'))),
+            "tab" => Some(Event::Key(Key::Char('\t'))),
+            "backspace" => Some(Event::Key(Key::Backspace)),
+            "left" => Some(Event::Key(Key::Left)),
+            "right" => Some(Event::Key(Key::Right)),
+            "up" => Some(Event::Key(Key::Up)),
+            "down" => Some(Event::Key(Key::Down)),
+            "home" => Some(Event::Key(Key::Home)),
+            "end" => Some(Event::Key(Key::End)),
+            "pageup" => Some(Event::Key(Key::PageUp)),
+            "pagedown" => Some(Event::Key(Key::PageDown)),
+            "delete" => Some(Event::Key(Key::Delete)),
+            "insert" => Some(Event::Key(Key::Insert)),
+            "escape" => Some(Event::Key(Key::Esc)),
+
+            x if x.starts_with("f") => {
+                match x[1..].parse::<u8>() {
+                    Ok(val) => Some(Event::Key(Key::F(val))),
+                    Err(_) => {
+                        warn!("Cannot parse {}", x);
+                        None
+                    }
+                }
+            }
+
+            x if x.starts_with("ctrl+") || x.starts_with("alt+") => {
+                let is_alt = x.starts_with("alt+");
+                let start_length = if is_alt {4} else {5};
+
+                let character;
+                // start_length + "shift+x".len() || start_length + "x".len()
+                if x.len() != start_length + 7 && x.len() != start_length + 1 {
+                    warn!("Cannot parse {}. Length is = {}, which is neither {} nor {} ", x, x.len(), start_length + 1, start_length + 7);
+                    return None
+                } else {
+                    if x.len() == start_length + 7 {
+                        // With "+shift+", so we use an upper case letter
+                        character = x.chars().last().unwrap().to_ascii_uppercase();
+                    } else {
+                        character = x.chars().last().unwrap().to_ascii_lowercase();
+                    }                   
+                }
+
+                if is_alt {
+                    Some(Event::Key(Key::Alt(character)))
+                } else {
+                    Some(Event::Key(Key::Ctrl(character)))
+                }
+            }
+
+            x => {
+                warn!("Completely unknown argument {}", x);
+                None
+            },
+        }
+    }
+}

src/core/mod.rs

@@ -5,4 +5,7 @@ mod tui;
 pub use self::tui::{CoreEvent, Tui, TuiService, TuiServiceBuilder};
 
 mod cmd;
-pub use self::cmd::{Command, ParseCommandError};
+pub use self::cmd::{Command, ParseCommandError, RelativeMove, AbsoluteMove, RelativeMoveDistance, AbsoluteMovePoint};
+
+mod config;
+pub use self::config::{KeybindingConfig, Keymap};