language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-09-30 15:21:12 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

finished tests, some restructuring, bugfixes

Browse source
This commit is contained in:
Anton-4 2021-01-30 12:09:14 +01:00
parent a5ac077ec9
commit f3f57a13ef
9 changed files with 189 additions and 198 deletions
Download patch file Download diff file Expand all files Collapse all files

8
editor/src/error.rs
View file

@ -15,12 +15,12 @@ pub enum EdError {
#[snafu(display("ClipboardWriteFailed: could not set clipboard contents: {}", err_msg))]
ClipboardWriteFailed { err_msg: String },
#[snafu(display("ClipboardInitFailed: could not initialize ClipboardContext: {}.", err_msg))]
#[snafu(display(
"ClipboardInitFailed: could not initialize ClipboardContext: {}.",
err_msg
))]
ClipboardInitFailed { err_msg: String },
#[snafu(display("EdModelIsNone: editor model EdModel was never succesfully initiliazed."))]
EdModelIsNone { },
#[snafu(display(
"FileOpenFailed: failed to open file with path {} with the following error: {}.",
path_str,

27
editor/src/keyboard_input.rs
View file

@ -1,8 +1,8 @@
use crate::error::EdResult;
use crate::mvc::app_model::AppModel;
use crate::mvc::app_update::{pass_keydown_to_focused, handle_copy, handle_paste};
use winit::event::{ElementState, ModifiersState, VirtualKeyCode};
use crate::mvc::app_update::{handle_copy, handle_paste, pass_keydown_to_focused};
use winit::event::VirtualKeyCode::*;
use winit::event::{ElementState, ModifiersState, VirtualKeyCode};
pub fn handle_keydown(
elem_state: ElementState,
@ -10,9 +10,8 @@ pub fn handle_keydown(
modifiers: ModifiersState,
app_model: &mut AppModel,
) -> EdResult<()> {
if let ElementState::Released = elem_state {
return Ok(())
return Ok(());
}
match virtual_keycode {
@ -28,17 +27,23 @@ pub fn handle_keydown(
todo!("cut");
}
C => if modifiers.ctrl() {
C => {
if modifiers.ctrl() {
handle_copy(app_model)?
},
V => if modifiers.ctrl() {
}
}
V => {
if modifiers.ctrl() {
handle_paste(app_model)?
},
X => if modifiers.ctrl() {
}
}
X => {
if modifiers.ctrl() {
//handle_cut(app_model)?
todo!("cut");
},
_ => ()
}
}
_ => (),
}
Ok(())

2
editor/src/lib.rs
View file

@ -25,7 +25,7 @@ use crate::graphics::style::CODE_FONT_SIZE;
use crate::graphics::style::CODE_TXT_XY;
use crate::mvc::app_model::AppModel;
use crate::mvc::ed_model::EdModel;
use crate::mvc::{ed_model, ed_view, app_update};
use crate::mvc::{app_update, ed_model, ed_view};
use crate::resources::strings::NOTHING_OPENED;
use crate::vec_result::get_res;
use bumpalo::Bump;

81
editor/src/mvc/app_model.rs
View file

@ -1,10 +1,9 @@
use super::ed_model::EdModel;
use crate::error::{EdResult, print_err};
use crate::error::EdError::{ClipboardReadFailed, ClipboardWriteFailed, ClipboardInitFailed, EdModelIsNone};
use crate::error::EdError::{ClipboardInitFailed, ClipboardReadFailed, ClipboardWriteFailed};
use crate::error::{print_err, EdResult};
use clipboard::{ClipboardContext, ClipboardProvider};
use std::fmt;
#[derive(Debug)]
pub struct AppModel {
pub ed_model_opt: Option<EdModel>,
@ -13,59 +12,38 @@ pub struct AppModel {
impl AppModel {
pub fn init(ed_model_opt: Option<EdModel>) -> AppModel {
AppModel {
ed_model_opt,
clipboard_opt: AppModel::init_clipboard_opt(),
}
}
pub fn init_clipboard_opt() -> Option<Clipboard> {
let clipboard_res = Clipboard::init();
let clipboard_opt =
match clipboard_res {
Ok(clipboard) => Some(clipboard),
Err(e) => {
print_err(&e);
None
}
};
AppModel {
ed_model_opt,
clipboard_opt
}
}
pub fn get_ed_model(&self) -> EdResult<&EdModel> {
if let Some(ref ed_model) = self.ed_model_opt {
Ok(ed_model)
} else {
Err(EdModelIsNone {})
}
}
pub fn get_ed_model_mut(&mut self) -> EdResult<& mut EdModel> {
if let Some(ref mut ed_model) = self.ed_model_opt {
Ok(ed_model)
} else {
Err(EdModelIsNone {})
}
}
}
pub struct Clipboard {
context: ClipboardContext
context: ClipboardContext,
}
impl Clipboard {
pub fn init() -> EdResult<Clipboard> {
let context_res = ClipboardProvider::new();
match context_res {
Ok(context) => Ok(
Clipboard {
context
}
),
Ok(context) => Ok(Clipboard { context }),
Err(e) => Err(ClipboardInitFailed {
err_msg: e.to_string()
})
err_msg: e.to_string(),
}),
}
}
@ -76,8 +54,8 @@ impl Clipboard {
match content_res {
Ok(content_str) => Ok(content_str),
Err(e) => Err(ClipboardReadFailed {
err_msg: e.to_string()
})
err_msg: e.to_string(),
}),
}
}
@ -87,16 +65,37 @@ impl Clipboard {
match content_set_res {
Ok(_) => Ok(()),
Err(e) => Err(ClipboardWriteFailed {
err_msg: e.to_string()
})
err_msg: e.to_string(),
}),
}
}
}
pub fn set_clipboard_txt(clipboard_opt: &mut Option<Clipboard>, txt: &str) -> EdResult<()> {
if let Some(ref mut clipboard) = clipboard_opt {
clipboard.set_content(txt.to_owned())?;
} else {
return Err(ClipboardWriteFailed {
err_msg: "Clipboard was never initialized succesfully.".to_owned(),
});
}
Ok(())
}
pub fn get_clipboard_txt(clipboard_opt: &mut Option<Clipboard>) -> EdResult<String> {
if let Some(ref mut clipboard) = clipboard_opt {
clipboard.get_content()
} else {
Err(ClipboardReadFailed {
err_msg: "Clipboard was never initialized succesfully.".to_owned(),
})
}
}
impl fmt::Debug for Clipboard {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
// showing the clipboard would require a mut ref which is not possible
f.debug_struct("Clipboard (can't show)")
.finish()
f.debug_struct("Clipboard (can't show)").finish()
}
}

159
editor/src/mvc/app_update.rs
View file

@ -1,24 +1,17 @@
use super::app_model;
use super::app_model::AppModel;
use super::ed_model::Position;
use super::ed_update;
use super::ed_model::{Position};
use crate::error::EdResult;
use crate::error::EdError::{ClipboardWriteFailed, ClipboardReadFailed};
use winit::event::{ModifiersState, VirtualKeyCode};
pub fn handle_copy(app_model: &mut AppModel) -> EdResult<()> {
if let Some(ref mut ed_model) = app_model.ed_model_opt {
if ed_model.has_focus {
let selected_str_opt = super::ed_model::get_selected_str(ed_model)?;
if let Some(selected_str) = selected_str_opt {
if let Some(ref mut clipboard) = app_model.clipboard_opt {
clipboard.set_content(selected_str.to_owned())?;
} else {
return Err(ClipboardWriteFailed {
err_msg: "Clipboard was never initialized succesfully.".to_owned()
})
}
app_model::set_clipboard_txt(&mut app_model.clipboard_opt, selected_str)?;
}
}
}
@ -27,14 +20,11 @@ pub fn handle_copy(app_model: &mut AppModel) -> EdResult<()> {
}
pub fn handle_paste(app_model: &mut AppModel) -> EdResult<()> {
if let Some(ref mut ed_model) = app_model.ed_model_opt {
if ed_model.has_focus {
if let Some(ref mut clipboard) = app_model.clipboard_opt {
let clipboard_content = clipboard.get_content()?;
let clipboard_content = app_model::get_clipboard_txt(&mut app_model.clipboard_opt)?;
if !clipboard_content.is_empty() {
let mut rsplit_iter = clipboard_content.rsplit('\n');
// safe unwrap because we checked if empty
let last_line_nr_chars = rsplit_iter.next().unwrap().len();
@ -47,32 +37,38 @@ pub fn handle_paste(app_model: &mut AppModel) -> EdResult<()> {
ed_model.text_buf.del_selection(selection)?;
ed_model.selection_opt = None;
ed_model.text_buf.insert_str(
start_caret_pos,
&clipboard_content
)?;
ed_model
.text_buf
.insert_str(start_caret_pos, &clipboard_content)?;
if clipboard_nr_lines > 0 {
ed_model.caret_pos = Position {
line: start_caret_pos.line + clipboard_nr_lines,
column: start_caret_pos.column + last_line_nr_chars
column: last_line_nr_chars,
}
} else {
ed_model.text_buf.insert_str(
old_caret_pos,
&clipboard_content
)?;
ed_model.caret_pos = Position {
line: start_caret_pos.line,
column: start_caret_pos.column + last_line_nr_chars,
}
}
} else {
ed_model
.text_buf
.insert_str(old_caret_pos, &clipboard_content)?;
if clipboard_nr_lines > 0 {
ed_model.caret_pos = Position {
line: old_caret_pos.line + clipboard_nr_lines,
column: old_caret_pos.column + last_line_nr_chars
column: last_line_nr_chars,
}
}
}
} else {
return Err(ClipboardReadFailed {
err_msg: "Clipboard was never initialized succesfully.".to_owned()
})
ed_model.caret_pos = Position {
line: old_caret_pos.line,
column: old_caret_pos.column + last_line_nr_chars,
}
}
}
}
}
}
@ -104,108 +100,107 @@ pub fn handle_new_char(received_char: &char, app_model: &mut AppModel) -> EdResu
#[cfg(test)]
pub mod test_app_update {
use crate::mvc::app_model;
use crate::mvc::app_model::{AppModel, Clipboard};
use crate::mvc::app_update::{handle_copy, handle_paste};
use crate::mvc::ed_update::test_ed_update::{gen_caret_text_buf};
use crate::mvc::ed_model::{EdModel, Position, RawSelection};
use crate::selection::test_selection::{convert_selection_to_dsl, all_lines_vec};
use crate::mvc::ed_update::test_ed_update::gen_caret_text_buf;
use crate::selection::test_selection::{all_lines_vec, convert_selection_to_dsl};
use crate::text_buffer::TextBuffer;
use crate::error::EdResult;
use crate::error::EdError::ClipboardInitFailed;
pub fn mock_app_model(
text_buf: TextBuffer,
caret_pos: Position,
selection_opt: Option<RawSelection>,
clipboard_opt: Option<Clipboard>,
) -> AppModel {
AppModel::init(
Some(
EdModel {
AppModel {
ed_model_opt: Some(EdModel {
text_buf,
caret_pos,
selection_opt,
glyph_dim_rect_opt: None,
has_focus: true,
}
)
)
}
fn get_clipboard(app_model: &mut AppModel) -> EdResult<&mut Clipboard> {
if let Some(ref mut clipboard) = app_model.clipboard_opt {
Ok(clipboard)
} else {
Err(ClipboardInitFailed {
err_msg: "Clipboard was never initialized succesfully.".to_owned()
})
}),
clipboard_opt,
}
}
fn assert_copy(
pre_lines_str: &[&str],
expected_clipboard_content: &str,
) -> Result<(), String> {
clipboard_opt: Option<Clipboard>,
) -> Result<Option<Clipboard>, String> {
let (caret_pos, selection_opt, pre_text_buf) = gen_caret_text_buf(pre_lines_str)?;
let mut app_model = mock_app_model(pre_text_buf, caret_pos, selection_opt);
let mut app_model = mock_app_model(pre_text_buf, caret_pos, selection_opt, clipboard_opt);
handle_copy(&mut app_model)?;
let clipboard = get_clipboard(&mut app_model)?;
let clipboard_content = app_model::get_clipboard_txt(&mut app_model.clipboard_opt)?;
assert_eq!(
clipboard.get_content()?,
expected_clipboard_content
);
assert_eq!(clipboard_content, expected_clipboard_content);
Ok(())
Ok(app_model.clipboard_opt)
}
fn assert_paste(
pre_lines_str: &[&str],
clipboard_content: &str,
expected_post_lines_str: &[&str],
) -> Result<(), String> {
clipboard_opt: Option<Clipboard>,
) -> Result<Option<Clipboard>, String> {
let (caret_pos, selection_opt, pre_text_buf) = gen_caret_text_buf(pre_lines_str)?;
let mut app_model = mock_app_model(pre_text_buf, caret_pos, selection_opt);
let clipboard = get_clipboard(&mut app_model)?;
clipboard.set_content(clipboard_content.to_owned())?;
let mut app_model = mock_app_model(pre_text_buf, caret_pos, selection_opt, clipboard_opt);
app_model::set_clipboard_txt(&mut app_model.clipboard_opt, clipboard_content)?;
handle_paste(&mut app_model)?;
let ed_model = app_model.get_ed_model()?;
let ed_model = app_model.ed_model_opt.unwrap();
let mut text_buf_lines = all_lines_vec(&ed_model.text_buf);
let post_lines_str = convert_selection_to_dsl(
ed_model.selection_opt,
ed_model.caret_pos,
&mut text_buf_lines
&mut text_buf_lines,
)?;
assert_eq!(
post_lines_str,
expected_post_lines_str
);
assert_eq!(post_lines_str, expected_post_lines_str);
Ok(())
Ok(app_model.clipboard_opt)
}
#[test]
fn copy() -> Result<(), String> {
assert_copy(&["[a]|"], "a")?;
assert_copy(&["|[b]"], "b")?;
assert_copy(&["a[ ]|"], " ")?;
assert_copy(&["[ ]|b"], " ")?;
assert_copy(&["a\n", "[b\n", "]|"], "b\n")?;
assert_copy(&["[a\n", " b\n", "]|"], "a\n b\n")?;
assert_copy(&["abc\n", "d[ef\n", "ghi]|\n", "jkl"], "ef\nghi")?;
fn copy_paste() -> Result<(), String> {
// can only init clipboard once
let mut clipboard_opt = AppModel::init_clipboard_opt();
Ok(())
}
#[test]
fn paste() -> Result<(), String> {
assert_paste(&["|"], "", &["|"])?;
clipboard_opt = assert_copy(&["[a]|"], "a", clipboard_opt)?;
clipboard_opt = assert_copy(&["|[b]"], "b", clipboard_opt)?;
clipboard_opt = assert_copy(&["a[ ]|"], " ", clipboard_opt)?;
clipboard_opt = assert_copy(&["[ ]|b"], " ", clipboard_opt)?;
clipboard_opt = assert_copy(&["a\n", "[b\n", "]|"], "b\n", clipboard_opt)?;
clipboard_opt = assert_copy(&["[a\n", " b\n", "]|"], "a\n b\n", clipboard_opt)?;
clipboard_opt = assert_copy(
&["abc\n", "d[ef\n", "ghi]|\n", "jkl"],
"ef\nghi",
clipboard_opt,
)?;
clipboard_opt = assert_paste(&["|"], "", &["|"], clipboard_opt)?;
clipboard_opt = assert_paste(&["|"], "a", &["a|"], clipboard_opt)?;
clipboard_opt = assert_paste(&["a|"], "b", &["ab|"], clipboard_opt)?;
clipboard_opt = assert_paste(&["|a"], "b", &["b|a"], clipboard_opt)?;
clipboard_opt = assert_paste(&["[a]|"], "c", &["c|"], clipboard_opt)?;
clipboard_opt = assert_paste(&["[ab]|"], "d", &["d|"], clipboard_opt)?;
clipboard_opt = assert_paste(&["a[b]|c"], "e", &["ae|c"], clipboard_opt)?;
clipboard_opt = assert_paste(&["a\n", "[b\n", "]|"], "f", &["a\n", "f|"], clipboard_opt)?;
assert_paste(
&["abc\n", "d[ef\n", "ghi]|\n", "jkl"],
"ef\nghi",
&["abc\n", "def\n", "ghi|\n", "jkl"],
clipboard_opt,
)?;
Ok(())
}

9
editor/src/mvc/ed_model.rs
View file

@ -6,7 +6,6 @@ use std::cmp::Ordering;
use std::fmt;
use std::path::Path;
#[derive(Debug)]
pub struct EdModel {
pub text_buf: TextBuffer,
@ -30,13 +29,9 @@ pub fn get_selected_str(ed_model: &EdModel) -> EdResult<Option<&str>> {
if let Some(curr_selection) = ed_model.selection_opt {
let selected_str = ed_model.text_buf.get_selection(curr_selection)?;
Ok(
Some(selected_str)
)
Ok(Some(selected_str))
} else {
Ok(
None
)
Ok(None)
}
}

24
editor/src/mvc/ed_update.rs
View file

@ -1,12 +1,11 @@
use super::app_model::AppModel;
use super::ed_model::EdModel;
use super::ed_model::{Position, RawSelection};
use crate::error::EdResult;
use crate::text_buffer::TextBuffer;
use crate::util::is_newline;
use std::cmp::{max, min};
use winit::event::{ModifiersState, VirtualKeyCode};
use winit::event::VirtualKeyCode::*;
use winit::event::{ModifiersState, VirtualKeyCode};
pub type MoveCaretFun =
fn(Position, Option<RawSelection>, bool, &TextBuffer) -> (Position, Option<RawSelection>);
@ -352,7 +351,12 @@ pub fn handle_new_char(received_char: &char, ed_model: &mut EdModel) -> EdResult
ed_model.selection_opt = None;
}
'\u{3}' | '\u{16}' | '\u{30}' | '\u{e000}'..='\u{f8ff}' | '\u{f0000}'..='\u{ffffd}' | '\u{100000}'..='\u{10fffd}' => {
'\u{3}'
| '\u{16}'
| '\u{30}'
| '\u{e000}'..='\u{f8ff}'
| '\u{f0000}'..='\u{ffffd}'
| '\u{100000}'..='\u{10fffd}' => {
// chars that can be ignored
}
_ => {
@ -385,7 +389,7 @@ pub fn handle_new_char(received_char: &char, ed_model: &mut EdModel) -> EdResult
pub fn handle_key_down(
modifiers: &ModifiersState,
virtual_keycode: VirtualKeyCode,
ed_model: &mut EdModel
ed_model: &mut EdModel,
) {
match virtual_keycode {
Left => handle_arrow(move_caret_left, modifiers, ed_model),
@ -398,7 +402,7 @@ pub fn handle_key_down(
#[cfg(test)]
pub mod test_ed_update {
use crate::mvc::app_update::test_app_update::{mock_app_model};
use crate::mvc::app_update::test_app_update::mock_app_model;
use crate::mvc::ed_model::{Position, RawSelection};
use crate::mvc::ed_update::handle_new_char;
use crate::selection::test_selection::{
@ -423,14 +427,13 @@ pub mod test_ed_update {
) -> Result<(), String> {
let (caret_pos, selection_opt, pre_text_buf) = gen_caret_text_buf(pre_lines_str)?;
let mut app_model = mock_app_model(pre_text_buf, caret_pos, selection_opt);
let mut ed_model = app_model.get_ed_model_mut()?;
let app_model = mock_app_model(pre_text_buf, caret_pos, selection_opt, None);
let mut ed_model = app_model.ed_model_opt.unwrap();
if let Err(e) = handle_new_char(&new_char, ed_model) {
if let Err(e) = handle_new_char(&new_char, &mut ed_model) {
return Err(e.to_string());
}
if let Some(ed_model) = app_model.ed_model_opt {
let mut actual_lines = all_lines_vec(&ed_model.text_buf);
let dsl_slice = convert_selection_to_dsl(
ed_model.selection_opt,
@ -439,9 +442,6 @@ pub mod test_ed_update {
)
.unwrap();
assert_eq!(dsl_slice, expected_post_lines_str);
} else {
panic!("Mock AppModel did not have an EdModel.");
}
Ok(())
}

2
editor/src/mvc/mod.rs
View file

@ -1,5 +1,5 @@
pub mod app_model;
pub mod app_update;
pub mod ed_model;
pub mod ed_view;
pub mod ed_update;
pub mod ed_view;

5
editor/src/text_buffer.rs
View file

@ -101,10 +101,7 @@ impl TextBuffer {
}
pub fn line_len(&self, line_nr: usize) -> Option<usize> {
self.line(line_nr)
.map(
|line| line.len()
)
self.line(line_nr).map(|line| line.len())
}
pub fn line_len_res(&self, line_nr: usize) -> EdResult<usize> {