Sublime-like changes

Cargo.toml

@@ -14,3 +14,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

@@ -5,7 +5,7 @@ use xrl::ViewId;
 
 use std::str::FromStr;
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq, Clone)]
 pub enum Command {
     /// Close the CommandPrompt.
     Cancel,
@@ -39,6 +39,8 @@ pub enum Command {
     SetTheme(String),
     /// Toggle displaying line numbers.
     ToggleLineNumbers,
+    /// Open prompt for user-input
+    OpenPrompt,
 }
 
 #[derive(Debug)]
@@ -67,18 +69,19 @@ 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),
+            "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),
             "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),
             "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,135 @@
+use crate::core::Command;
+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;
+
+#[derive(Debug, Serialize, Deserialize)]
+struct Keybinding {
+    keys: Vec<String>,
+    command: String,
+    // For now, unstructured value
+    args: Option<Value>,
+    context: Option<Value>,
+}
+
+pub struct KeybindingConfig {
+	pub keymap: HashMap<Event, Command>,
+	pub config_path: PathBuf
+}
+
+impl KeybindingConfig {
+	pub fn parse(config_path: &Path) -> Result<KeybindingConfig, Box<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 = HashMap::new();
+    	let mut found_cmds = Vec::new();
+    	for binding in bindings {
+    		let cmd = match Command::from_str(&binding.command) {
+    			Ok(cmd) => cmd,
+    			// unimplemented command for now
+    			Err(_) => continue,
+    		};
+    		error!("{:?} = {:?}", cmd, binding.keys);
+    		if found_cmds.contains(&cmd) {
+    			continue;
+    		}
+    		let binding = KeybindingConfig::parse_keys(&binding.keys).ok_or("Could not parse keybindings - config")?;
+    		keymap.insert(binding, cmd.clone());
+    		found_cmds.push(cmd);
+    	}
+
+    	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

@@ -6,3 +6,6 @@ pub use self::tui::{CoreEvent, Tui, TuiService, TuiServiceBuilder};
 
 mod cmd;
 pub use self::cmd::{Command, ParseCommandError};
+
+mod config;
+pub use self::config::{KeybindingConfig};

src/core/tui.rs

@@ -4,12 +4,12 @@ use futures::sync::mpsc::{unbounded, UnboundedReceiver, UnboundedSender};
 use futures::sync::oneshot::{self, Receiver, Sender};
 use futures::{Async, Future, Poll, Sink, Stream};
 
-use termion::event::{Event, Key};
+use termion::event::{Event};
 use xrl::{Client, Frontend, FrontendBuilder, MeasureWidth, XiNotification};
 
 use failure::Error;
 
-use core::{Command, Terminal, TerminalEvent};
+use core::{Command, Terminal, TerminalEvent, KeybindingConfig};
 use widgets::{CommandPrompt, Editor};
 
 pub struct Tui {
@@ -32,18 +32,21 @@ pub struct Tui {
 
     /// Stream of messages from Xi core.
     core_events: UnboundedReceiver<CoreEvent>,
+
+    keybindings: KeybindingConfig,
 }
 
 impl Tui {
     /// Create a new Tui instance.
-    pub fn new(client: Client, events: UnboundedReceiver<CoreEvent>) -> Result<Self, Error> {
+    pub fn new(client: Client, events: UnboundedReceiver<CoreEvent>, keybindings: KeybindingConfig) -> Result<Self, Error> {
         Ok(Tui {
             terminal: Terminal::new()?,
             exit: false,
             term_size: (0, 0),
             editor: Editor::new(client),
             prompt: None,
             core_events: events,
+            keybindings: keybindings,
         })
     }
 
@@ -54,9 +57,8 @@ impl Tui {
 
     pub fn run_command(&mut self, cmd: Command) {
         match cmd {
-            Command::Cancel => {
-                self.prompt = None;
-            }
+            Command::OpenPrompt => self.open_prompt(),
+            Command::Cancel => self.prompt = None,
             Command::Quit => self.exit = true,
             Command::Save(view) => self.editor.save(view),
             Command::Back => self.editor.back(),
@@ -75,40 +77,43 @@ impl Tui {
         }
     }
 
+    fn open_prompt(&mut self) {
+        if self.prompt.is_none() {
+            self.prompt = Some(CommandPrompt::default());
+        }
+    }
+
     /// Global keybindings can be parsed here
     fn handle_input(&mut self, event: Event) {
         debug!("handling input {:?}", event);
-        match event {
-            Event::Key(Key::Ctrl('c')) => self.exit = true,
-            Event::Key(Key::Alt('x')) => {
-                if let Some(ref mut prompt) = self.prompt {
-                    match prompt.handle_input(&event) {
-                        Ok(None) => {}
-                        Ok(Some(_)) => unreachable!(),
-                        Err(_) => unreachable!(),
-                    }
-                } else {
-                    self.prompt = Some(CommandPrompt::default());
-                }
+
+        if let Some(cmd) = self.keybindings.keymap.get(&event) {
+            match cmd {
+                Command::OpenPrompt => {
+                                        if self.prompt.is_none() {
+                                            self.prompt = Some(CommandPrompt::default());
+                                        }
+                                        return; },
+                Command::Quit => { self.exit = true; return; },
+                _ => {/* Somebody else has to deal with these commands */},
             }
-            event => {
-                // No command prompt is active, process the event normally.
-                if self.prompt.is_none() {
-                    self.editor.handle_input(event);
-                    return;
-                }
+        }
 
-                // A command prompt is active.
-                let mut prompt = self.prompt.take().unwrap();
-                match prompt.handle_input(&event) {
-                    Ok(None) => {
-                        self.prompt = Some(prompt);
-                    }
-                    Ok(Some(cmd)) => self.run_command(cmd),
-                    Err(err) => {
-                        error!("Failed to parse command: {:?}", err);
-                    }
-                }
+        // No command prompt is active, process the event normally.
+        if self.prompt.is_none() {
+            self.editor.handle_input(event);
+            return;
+        }
+
+        // A command prompt is active.
+        let mut prompt = self.prompt.take().unwrap();
+        match prompt.handle_input(&event) {
+            Ok(None) => {
+                self.prompt = Some(prompt);
+            }
+            Ok(Some(cmd)) => self.run_command(cmd),
+            Err(err) => {
+                error!("Failed to parse command: {:?}", err);
             }
         }
     }

src/main.rs

@@ -18,6 +18,10 @@ extern crate tokio;
 extern crate xdg;
 extern crate xrl;
 
+extern crate json5;
+extern crate serde;
+extern crate serde_json;
+
 mod core;
 mod widgets;
 use xdg::BaseDirectories;
@@ -29,7 +33,7 @@ use log4rs::append::file::FileAppender;
 use log4rs::config::{Appender, Config, Logger, Root};
 use xrl::spawn;
 
-use core::{Command, Tui, TuiServiceBuilder};
+use core::{Command, Tui, TuiServiceBuilder, KeybindingConfig};
 
 fn configure_logs(logfile: &str) {
     let tui = FileAppender::builder().build(logfile).unwrap();
@@ -93,6 +97,9 @@ fn run() -> Result<(), Error> {
         configure_logs(logfile);
     }
 
+    let configfile = std::path::Path::new("./configs/Default (Linux).sublime-keymap").to_owned();
+    let keybindings = KeybindingConfig::parse(&configfile).map_err(Error::from_boxed_compat)?;
+
     tokio::run(future::lazy(move || {
         info!("starting xi-core");
         let (tui_service_builder, core_events_rx) = TuiServiceBuilder::new();
@@ -122,7 +129,7 @@ fn run() -> Result<(), Error> {
                 .map_err(|e| error!("failed to send \"client_started\" {:?}", e))
                 .and_then(move |_| {
                     info!("initializing the TUI");
-                    let mut tui = Tui::new(client_clone, core_events_rx)
+                    let mut tui = Tui::new(client_clone, core_events_rx, keybindings)
                         .expect("failed to initialize the TUI");
                     tui.run_command(Command::Open(
                         matches.value_of("file").map(ToString::to_string),