mdt_core 0.7.0

update markdown content anywhere using comments as template tags
Documentation 
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
126
127
128
129
130
131
132
133
134
135
136
137
138

use std::fmt::Debug;
use std::fmt::Display;

use markdown::unist::Point as UnistPoint;
use markdown::unist::Position as UnistPosition;
use serde::Deserialize;
use serde::Serialize;

/// One place in a source file. This is taken from the [unist] crate with the
/// `Copy` trait added.
#[derive(Clone, Copy, Eq, PartialEq, Serialize, Deserialize)]
pub struct Point {
	/// 1-indexed integer representing a line in a source file.
	pub line: usize,
	/// 1-indexed integer representing a column in a source file.
	pub column: usize,
	/// 0-indexed integer representing a character in a source file.
	pub offset: usize,
}

impl Point {
	#[must_use]
	pub fn new(line: usize, column: usize, offset: usize) -> Point {
		Self {
			line,
			column,
			offset,
		}
	}

	pub fn advance_str(&mut self, text: &str) {
		for byte in text.bytes() {
			if byte == b'\n' {
				self.line += 1;
				self.column = 0;
				self.offset += 1;
			} else {
				self.column += 1;
				self.offset += 1;
			}
		}
	}

	pub fn advance(&mut self, text: impl Display) {
		self.advance_str(&text.to_string());
	}
}

impl From<UnistPoint> for Point {
	fn from(point: UnistPoint) -> Self {
		Self {
			line: point.line,
			column: point.column,
			offset: point.offset,
		}
	}
}

impl Debug for Point {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		write!(f, "{}:{} ({})", self.line, self.column, self.offset)
	}
}

/// Location of a node in a source file. This is taken from the `unist` crate
/// with the `Copy` trait added.
#[derive(Clone, Copy, Eq, PartialEq, Serialize, Deserialize)]
pub struct Position {
	/// Represents the place of the first character of the parsed source region.
	pub start: Point,
	/// Represents the place of the first character after the parsed source
	/// region, whether it exists or not.
	pub end: Point,
}

impl Position {
	#[must_use]
	pub fn new(
		start_line: usize,
		start_column: usize,
		start_offset: usize,
		end_line: usize,
		end_column: usize,
		end_offset: usize,
	) -> Position {
		Self {
			start: Point::new(start_line, start_column, start_offset),
			end: Point::new(end_line, end_column, end_offset),
		}
	}

	pub fn from_point(point: Point) -> Self {
		Self {
			start: point,
			end: point,
		}
	}

	pub fn from_points(start: Point, end: Point) -> Self {
		Self { start, end }
	}

	pub fn advance_start_str(&mut self, text: &str) {
		self.start.advance_str(text);
	}

	pub fn advance_start(&mut self, text: impl Display) {
		self.start.advance(text);
	}

	pub fn advance_end(&mut self, text: impl Display) {
		self.end.advance(text);
	}
}

impl From<UnistPosition> for Position {
	fn from(position: UnistPosition) -> Self {
		Self {
			start: Point::from(position.start),
			end: Point::from(position.end),
		}
	}
}

impl Debug for Position {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		write!(
			f,
			"{}:{}-{}:{} ({}-{})",
			self.start.line,
			self.start.column,
			self.end.line,
			self.end.column,
			self.start.offset,
			self.end.offset
		)
	}
}