mirror of
https://github.com/ilyakooo0/helix.git
synced 2024-09-11 16:07:00 +03:00
wip: importing to github
This commit is contained in:
parent
6905ff03c2
commit
613d06dfb0
44
Cargo.lock
generated
44
Cargo.lock
generated
@ -59,6 +59,12 @@ version = "1.2.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693"
|
||||
|
||||
[[package]]
|
||||
name = "cassowary"
|
||||
version = "0.3.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "df8670b8c7b9dae1793364eafadf7239c40d669904660c5960d74cfd80b46a53"
|
||||
|
||||
[[package]]
|
||||
name = "cc"
|
||||
version = "1.0.54"
|
||||
@ -176,6 +182,12 @@ dependencies = [
|
||||
"winapi",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "either"
|
||||
version = "1.5.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "bb1f6b1ce1c140482ea30ddd3335fc0024ac7ee112895426e0a629a6c20adfe3"
|
||||
|
||||
[[package]]
|
||||
name = "futf"
|
||||
version = "0.1.4"
|
||||
@ -298,6 +310,8 @@ dependencies = [
|
||||
"ropey",
|
||||
"smallvec",
|
||||
"tendril",
|
||||
"unicode-segmentation",
|
||||
"unicode-width",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@ -312,6 +326,7 @@ dependencies = [
|
||||
"num_cpus",
|
||||
"piper",
|
||||
"smol",
|
||||
"tui",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@ -323,6 +338,15 @@ dependencies = [
|
||||
"libc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "itertools"
|
||||
version = "0.9.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "284f18f85651fe11e8a991b2adb42cb078325c996ed026d994719efcfca1d54b"
|
||||
dependencies = [
|
||||
"either",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "lazy_static"
|
||||
version = "1.4.0"
|
||||
@ -651,12 +675,32 @@ dependencies = [
|
||||
"utf-8",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tui"
|
||||
version = "0.9.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9533d39bef0ae8f510e8a99d78702e68d1bbf0b98a78ec9740509d287010ae1e"
|
||||
dependencies = [
|
||||
"bitflags",
|
||||
"cassowary",
|
||||
"either",
|
||||
"itertools",
|
||||
"unicode-segmentation",
|
||||
"unicode-width",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "unicode-segmentation"
|
||||
version = "1.6.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e83e153d1053cbb5a118eeff7fd5be06ed99153f00dbcd8ae310c5fb2b22edc0"
|
||||
|
||||
[[package]]
|
||||
name = "unicode-width"
|
||||
version = "0.1.7"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "caaa9d531767d1ff2150b9332433f32a24622147e5ebb1f26409d5da67afd479"
|
||||
|
||||
[[package]]
|
||||
name = "unicode-xid"
|
||||
version = "0.2.0"
|
||||
|
@ -12,4 +12,6 @@ ropey = { git = "https://github.com/cessen/ropey" }
|
||||
anyhow = "1.0.31"
|
||||
smallvec = "1.4.0"
|
||||
tendril = { git = "https://github.com/servo/tendril" }
|
||||
unicode-segmentation = "1.6.0"
|
||||
unicode-width = "0.1.7"
|
||||
# slab = "0.4.2"
|
||||
|
213
helix-core/src/graphemes.rs
Normal file
213
helix-core/src/graphemes.rs
Normal file
@ -0,0 +1,213 @@
|
||||
// Based on https://github.com/cessen/led/blob/c4fa72405f510b7fd16052f90a598c429b3104a6/src/graphemes.rs
|
||||
use ropey::{iter::Chunks, str_utils::byte_to_char_idx, RopeSlice};
|
||||
use unicode_segmentation::{GraphemeCursor, GraphemeIncomplete};
|
||||
use unicode_width::UnicodeWidthStr;
|
||||
|
||||
pub fn grapheme_width(g: &str) -> usize {
|
||||
if g.as_bytes()[0] <= 127 {
|
||||
// Fast-path ascii.
|
||||
// Point 1: theoretically, ascii control characters should have zero
|
||||
// width, but in our case we actually want them to have width: if they
|
||||
// show up in text, we want to treat them as textual elements that can
|
||||
// be editied. So we can get away with making all ascii single width
|
||||
// here.
|
||||
// Point 2: we're only examining the first codepoint here, which means
|
||||
// we're ignoring graphemes formed with combining characters. However,
|
||||
// if it starts with ascii, it's going to be a single-width grapeheme
|
||||
// regardless, so, again, we can get away with that here.
|
||||
// Point 3: we're only examining the first _byte_. But for utf8, when
|
||||
// checking for ascii range values only, that works.
|
||||
1
|
||||
} else {
|
||||
// We use max(1) here because all grapeheme clusters--even illformed
|
||||
// ones--should have at least some width so they can be edited
|
||||
// properly.
|
||||
UnicodeWidthStr::width(g).max(1)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn nth_prev_grapheme_boundary(slice: &RopeSlice, char_idx: usize, n: usize) -> usize {
|
||||
// TODO: implement this more efficiently. This has to do a lot of
|
||||
// re-scanning of rope chunks. Probably move the main implementation here,
|
||||
// and have prev_grapheme_boundary call this instead.
|
||||
let mut char_idx = char_idx;
|
||||
for _ in 0..n {
|
||||
char_idx = prev_grapheme_boundary(slice, char_idx);
|
||||
}
|
||||
char_idx
|
||||
}
|
||||
|
||||
/// Finds the previous grapheme boundary before the given char position.
|
||||
pub fn prev_grapheme_boundary(slice: &RopeSlice, char_idx: usize) -> usize {
|
||||
// Bounds check
|
||||
debug_assert!(char_idx <= slice.len_chars());
|
||||
|
||||
// We work with bytes for this, so convert.
|
||||
let byte_idx = slice.char_to_byte(char_idx);
|
||||
|
||||
// Get the chunk with our byte index in it.
|
||||
let (mut chunk, mut chunk_byte_idx, mut chunk_char_idx, _) = slice.chunk_at_byte(byte_idx);
|
||||
|
||||
// Set up the grapheme cursor.
|
||||
let mut gc = GraphemeCursor::new(byte_idx, slice.len_bytes(), true);
|
||||
|
||||
// Find the previous grapheme cluster boundary.
|
||||
loop {
|
||||
match gc.prev_boundary(chunk, chunk_byte_idx) {
|
||||
Ok(None) => return 0,
|
||||
Ok(Some(n)) => {
|
||||
let tmp = byte_to_char_idx(chunk, n - chunk_byte_idx);
|
||||
return chunk_char_idx + tmp;
|
||||
}
|
||||
Err(GraphemeIncomplete::PrevChunk) => {
|
||||
let (a, b, c, _) = slice.chunk_at_byte(chunk_byte_idx - 1);
|
||||
chunk = a;
|
||||
chunk_byte_idx = b;
|
||||
chunk_char_idx = c;
|
||||
}
|
||||
Err(GraphemeIncomplete::PreContext(n)) => {
|
||||
let ctx_chunk = slice.chunk_at_byte(n - 1).0;
|
||||
gc.provide_context(ctx_chunk, n - ctx_chunk.len());
|
||||
}
|
||||
_ => unreachable!(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn nth_next_grapheme_boundary(slice: &RopeSlice, char_idx: usize, n: usize) -> usize {
|
||||
// TODO: implement this more efficiently. This has to do a lot of
|
||||
// re-scanning of rope chunks. Probably move the main implementation here,
|
||||
// and have next_grapheme_boundary call this instead.
|
||||
let mut char_idx = char_idx;
|
||||
for _ in 0..n {
|
||||
char_idx = next_grapheme_boundary(slice, char_idx);
|
||||
}
|
||||
char_idx
|
||||
}
|
||||
|
||||
/// Finds the next grapheme boundary after the given char position.
|
||||
pub fn next_grapheme_boundary(slice: &RopeSlice, char_idx: usize) -> usize {
|
||||
// Bounds check
|
||||
debug_assert!(char_idx <= slice.len_chars());
|
||||
|
||||
// We work with bytes for this, so convert.
|
||||
let byte_idx = slice.char_to_byte(char_idx);
|
||||
|
||||
// Get the chunk with our byte index in it.
|
||||
let (mut chunk, mut chunk_byte_idx, mut chunk_char_idx, _) = slice.chunk_at_byte(byte_idx);
|
||||
|
||||
// Set up the grapheme cursor.
|
||||
let mut gc = GraphemeCursor::new(byte_idx, slice.len_bytes(), true);
|
||||
|
||||
// Find the next grapheme cluster boundary.
|
||||
loop {
|
||||
match gc.next_boundary(chunk, chunk_byte_idx) {
|
||||
Ok(None) => return slice.len_chars(),
|
||||
Ok(Some(n)) => {
|
||||
let tmp = byte_to_char_idx(chunk, n - chunk_byte_idx);
|
||||
return chunk_char_idx + tmp;
|
||||
}
|
||||
Err(GraphemeIncomplete::NextChunk) => {
|
||||
chunk_byte_idx += chunk.len();
|
||||
let (a, _, c, _) = slice.chunk_at_byte(chunk_byte_idx);
|
||||
chunk = a;
|
||||
chunk_char_idx = c;
|
||||
}
|
||||
Err(GraphemeIncomplete::PreContext(n)) => {
|
||||
let ctx_chunk = slice.chunk_at_byte(n - 1).0;
|
||||
gc.provide_context(ctx_chunk, n - ctx_chunk.len());
|
||||
}
|
||||
_ => unreachable!(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns whether the given char position is a grapheme boundary.
|
||||
pub fn is_grapheme_boundary(slice: &RopeSlice, char_idx: usize) -> bool {
|
||||
// Bounds check
|
||||
debug_assert!(char_idx <= slice.len_chars());
|
||||
|
||||
// We work with bytes for this, so convert.
|
||||
let byte_idx = slice.char_to_byte(char_idx);
|
||||
|
||||
// Get the chunk with our byte index in it.
|
||||
let (chunk, chunk_byte_idx, _, _) = slice.chunk_at_byte(byte_idx);
|
||||
|
||||
// Set up the grapheme cursor.
|
||||
let mut gc = GraphemeCursor::new(byte_idx, slice.len_bytes(), true);
|
||||
|
||||
// Determine if the given position is a grapheme cluster boundary.
|
||||
loop {
|
||||
match gc.is_boundary(chunk, chunk_byte_idx) {
|
||||
Ok(n) => return n,
|
||||
Err(GraphemeIncomplete::PreContext(n)) => {
|
||||
let (ctx_chunk, ctx_byte_start, _, _) = slice.chunk_at_byte(n - 1);
|
||||
gc.provide_context(ctx_chunk, ctx_byte_start);
|
||||
}
|
||||
_ => unreachable!(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// An iterator over the graphemes of a RopeSlice.
|
||||
#[derive(Clone)]
|
||||
pub struct RopeGraphemes<'a> {
|
||||
text: RopeSlice<'a>,
|
||||
chunks: Chunks<'a>,
|
||||
cur_chunk: &'a str,
|
||||
cur_chunk_start: usize,
|
||||
cursor: GraphemeCursor,
|
||||
}
|
||||
|
||||
impl<'a> RopeGraphemes<'a> {
|
||||
pub fn new<'b>(slice: &RopeSlice<'b>) -> RopeGraphemes<'b> {
|
||||
let mut chunks = slice.chunks();
|
||||
let first_chunk = chunks.next().unwrap_or("");
|
||||
RopeGraphemes {
|
||||
text: *slice,
|
||||
chunks: chunks,
|
||||
cur_chunk: first_chunk,
|
||||
cur_chunk_start: 0,
|
||||
cursor: GraphemeCursor::new(0, slice.len_bytes(), true),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Iterator for RopeGraphemes<'a> {
|
||||
type Item = RopeSlice<'a>;
|
||||
|
||||
fn next(&mut self) -> Option<RopeSlice<'a>> {
|
||||
let a = self.cursor.cur_cursor();
|
||||
let b;
|
||||
loop {
|
||||
match self
|
||||
.cursor
|
||||
.next_boundary(self.cur_chunk, self.cur_chunk_start)
|
||||
{
|
||||
Ok(None) => {
|
||||
return None;
|
||||
}
|
||||
Ok(Some(n)) => {
|
||||
b = n;
|
||||
break;
|
||||
}
|
||||
Err(GraphemeIncomplete::NextChunk) => {
|
||||
self.cur_chunk_start += self.cur_chunk.len();
|
||||
self.cur_chunk = self.chunks.next().unwrap_or("");
|
||||
}
|
||||
_ => unreachable!(),
|
||||
}
|
||||
}
|
||||
|
||||
if a < self.cur_chunk_start {
|
||||
let a_char = self.text.byte_to_char(a);
|
||||
let b_char = self.text.byte_to_char(b);
|
||||
|
||||
Some(self.text.slice(a_char..b_char))
|
||||
} else {
|
||||
let a2 = a - self.cur_chunk_start;
|
||||
let b2 = b - self.cur_chunk_start;
|
||||
Some((&self.cur_chunk[a2..b2]).into())
|
||||
}
|
||||
}
|
||||
}
|
@ -1,4 +1,5 @@
|
||||
mod buffer;
|
||||
mod graphemes;
|
||||
mod selection;
|
||||
mod state;
|
||||
mod transaction;
|
||||
|
@ -99,8 +99,8 @@ pub fn extend(&self, from: usize, to: usize) -> Self {
|
||||
/// A selection consists of one or more selection ranges.
|
||||
pub struct Selection {
|
||||
// TODO: decide how many ranges to inline SmallVec<[Range; 1]>
|
||||
ranges: SmallVec<[Range; 1]>,
|
||||
primary_index: usize,
|
||||
pub(crate) ranges: SmallVec<[Range; 1]>,
|
||||
pub(crate) primary_index: usize,
|
||||
}
|
||||
|
||||
impl Selection {
|
||||
|
@ -1,17 +1,30 @@
|
||||
use crate::{Buffer, Selection};
|
||||
use crate::graphemes::{nth_next_grapheme_boundary, nth_prev_grapheme_boundary};
|
||||
use crate::{Buffer, Selection, SelectionRange};
|
||||
|
||||
/// A state represents the current editor state of a single buffer.
|
||||
pub struct State {
|
||||
// TODO: maybe doc: ?
|
||||
buffer: Buffer,
|
||||
doc: Buffer,
|
||||
selection: Selection,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone, PartialEq, Eq)]
|
||||
pub enum Direction {
|
||||
Forward,
|
||||
Backward,
|
||||
}
|
||||
#[derive(Copy, Clone, PartialEq, Eq)]
|
||||
pub enum Granularity {
|
||||
Character,
|
||||
Word,
|
||||
Line,
|
||||
// LineBoundary
|
||||
}
|
||||
|
||||
impl State {
|
||||
#[must_use]
|
||||
pub fn new(buffer: Buffer) -> Self {
|
||||
pub fn new(doc: Buffer) -> Self {
|
||||
Self {
|
||||
buffer,
|
||||
doc,
|
||||
selection: Selection::single(0, 0),
|
||||
}
|
||||
}
|
||||
@ -40,4 +53,67 @@ pub fn new(buffer: Buffer) -> Self {
|
||||
// syntax
|
||||
// foldable
|
||||
// changeFilter/transactionFilter
|
||||
|
||||
pub fn move_pos(
|
||||
&self,
|
||||
pos: usize,
|
||||
dir: Direction,
|
||||
granularity: Granularity,
|
||||
n: usize,
|
||||
) -> usize {
|
||||
let text = &self.doc.contents;
|
||||
match (dir, granularity) {
|
||||
(Direction::Backward, Granularity::Character) => {
|
||||
nth_prev_grapheme_boundary(&text.slice(..), pos, n)
|
||||
}
|
||||
(Direction::Forward, Granularity::Character) => {
|
||||
nth_next_grapheme_boundary(&text.slice(..), pos, n)
|
||||
}
|
||||
_ => pos,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn move_selection(
|
||||
&self,
|
||||
sel: Selection,
|
||||
dir: Direction,
|
||||
granularity: Granularity,
|
||||
// TODO: n
|
||||
) -> Selection {
|
||||
// TODO: move all selections according to normal cursor move semantics by collapsing it
|
||||
// into cursors and moving them vertically
|
||||
|
||||
let ranges = sel.ranges.into_iter().map(|range| {
|
||||
// let pos = if !range.is_empty() {
|
||||
// // if selection already exists, bump it to the start or end of current select first
|
||||
// if dir == Direction::Backward {
|
||||
// range.from()
|
||||
// } else {
|
||||
// range.to()
|
||||
// }
|
||||
// } else {
|
||||
let pos = self.move_pos(range.head, dir, granularity, 1)
|
||||
// };
|
||||
SelectionRange::new(pos, pos)
|
||||
});
|
||||
|
||||
Selection::new(ranges.collect(), sel.primary_index)
|
||||
// TODO: update selection in state via transaction
|
||||
}
|
||||
|
||||
pub fn extend_selection(
|
||||
&self,
|
||||
sel: Selection,
|
||||
dir: Direction,
|
||||
granularity: Granularity,
|
||||
n: usize,
|
||||
) -> Selection {
|
||||
let ranges = sel.ranges.into_iter().map(|range| {
|
||||
let pos = self.move_pos(range.head, dir, granularity, n);
|
||||
SelectionRange::new(range.anchor, pos)
|
||||
});
|
||||
|
||||
Selection::new(ranges.collect(), sel.primary_index)
|
||||
// TODO: update selection in state via transaction
|
||||
}
|
||||
}
|
||||
|
@ -29,3 +29,4 @@ futures = { version = "0.3.5", default-features = false, features = ["std"] }
|
||||
smol = "0.1.10"
|
||||
num_cpus = "1.13.0"
|
||||
piper = "0.1.2"
|
||||
tui = { version = "0.9.5", default-features = false }
|
||||
|
18
helix-term/src/component.rs
Normal file
18
helix-term/src/component.rs
Normal file
@ -0,0 +1,18 @@
|
||||
|
||||
// IDEA: render to a cache buffer, then if not changed, copy the buf into the parent
|
||||
pub trait Component {
|
||||
/// Process input events, return true if handled.
|
||||
fn process_event(&mut self, event: crossterm::event::Event, args) -> bool;
|
||||
/// Should redraw? Useful for saving redraw cycles if we know component didn't change.
|
||||
fn should_update(&self) -> bool { true }
|
||||
|
||||
fn render(&mut self, surface: &mut Surface, args: ());
|
||||
}
|
||||
|
||||
// HStack / VStack
|
||||
// focus by component id: each View/Editor gets it's own incremental id at create
|
||||
// Component: View(Arc<State>) -> multiple views can point to same state
|
||||
// id 0 = prompt?
|
||||
// when entering to prompt, it needs to direct Commands to last focus window
|
||||
// -> prompt.trigger(focus_id), on_leave -> focus(focus_id)
|
||||
// popups on another layer
|
@ -278,4 +278,11 @@ pub fn run(&mut self) -> Result<(), Error> {
|
||||
println!("The text you entered: {}", typed_text);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn render(&self) {
|
||||
// create a new window sized surface
|
||||
// paint all components
|
||||
// diff vs last frame, swap
|
||||
// paint diff
|
||||
}
|
||||
}
|
||||
|
@ -11,6 +11,8 @@
|
||||
use smol::Timer;
|
||||
// use futures_timer::Delay;
|
||||
|
||||
use tui::{backend::CrosstermBackend, Terminal};
|
||||
|
||||
use crossterm::{
|
||||
cursor::position,
|
||||
event::{DisableMouseCapture, EnableMouseCapture, Event, EventStream, KeyCode},
|
||||
@ -64,6 +66,9 @@ fn main() -> Result<()> {
|
||||
let mut stdout = stdout();
|
||||
execute!(stdout, EnableMouseCapture)?;
|
||||
|
||||
let backend = CrosstermBackend::new(stdout);
|
||||
let mut terminal = Terminal::new(backend)?;
|
||||
|
||||
use std::thread;
|
||||
|
||||
// Same number of threads as there are CPU cores.
|
||||
|
@ -1,4 +1,5 @@
|
||||
// mod editor;
|
||||
mod component;
|
||||
|
||||
// use editor::Editor;
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user