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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
|
//! Deal with bytes.
use crate::event::{Event, Kind, Point};
use crate::util::constant::TAB_SIZE;
use alloc::{format, string::String, vec};
use core::str;
/// A range between two points.
#[derive(Debug)]
pub struct Position<'a> {
/// Start point.
pub start: &'a Point,
/// End point.
pub end: &'a Point,
}
impl<'a> Position<'a> {
/// Get a position from an exit event.
///
/// Looks backwards for the corresponding `enter` event.
/// This does not support nested events (such as lists in lists).
///
/// ## Panics
///
/// This function panics if an enter event is given.
/// When `markdown-rs` is used, this function never panics.
pub fn from_exit_event(events: &'a [Event], index: usize) -> Position<'a> {
debug_assert_eq!(events[index].kind, Kind::Exit, "expected `exit` event");
let end = &events[index].point;
let name = &events[index].name;
let mut index = index - 1;
while !(events[index].kind == Kind::Enter && events[index].name == *name) {
index -= 1;
}
let start = &events[index].point;
Position { start, end }
}
/// Turn a position into indices.
///
/// Indices are places in `bytes` where this position starts and ends.
///
/// > 👉 **Note**: indices cannot represent virtual spaces.
pub fn to_indices(&self) -> (usize, usize) {
(self.start.index, self.end.index)
}
}
/// Bytes belonging to a range.
///
/// Includes info on virtual spaces before and after the bytes.
#[derive(Debug)]
pub struct Slice<'a> {
/// Bytes.
pub bytes: &'a [u8],
/// Number of virtual spaces before the bytes.
pub before: usize,
/// Number of virtual spaces after the bytes.
pub after: usize,
}
impl<'a> Slice<'a> {
/// Get a slice for a position.
pub fn from_position(bytes: &'a [u8], position: &Position) -> Slice<'a> {
let mut before = position.start.vs;
let mut after = position.end.vs;
let mut start = position.start.index;
let mut end = position.end.index;
// If we have virtual spaces before, it means we are past the actual
// character at that index, and those virtual spaces.
if before > 0 {
before = TAB_SIZE - before;
start += 1;
};
// If we have virtual spaces after, it means that character is included,
// and one less virtual space.
if after > 0 {
after -= 1;
end += 1;
}
Slice {
bytes: &bytes[start..end],
before,
after,
}
}
/// Get a slice for two indices.
///
/// > 👉 **Note**: indices cannot represent virtual spaces.
pub fn from_indices(bytes: &'a [u8], start: usize, end: usize) -> Slice<'a> {
Slice {
bytes: &bytes[start..end],
before: 0,
after: 0,
}
}
/// Get the size of this slice, including virtual spaces.
pub fn len(&self) -> usize {
self.bytes.len() + self.before + self.after
}
/// Turn the slice into a `&str`.
///
/// > 👉 **Note**: cannot represent virtual spaces.
pub fn as_str(&self) -> &str {
str::from_utf8(self.bytes).unwrap()
}
/// Turn the slice into a `String`.
///
/// Supports virtual spaces.
pub fn serialize(&self) -> String {
let prefix = String::from_utf8(vec![b' '; self.before]).unwrap();
let suffix = String::from_utf8(vec![b' '; self.after]).unwrap();
format!("{}{}{}", prefix, self.as_str(), suffix)
}
}
|
