Skip to main content

md_tui/nodes/
word.rs

1use ratatui::style::Color;
2
3use crate::parser::MdParseEnum;
4
5#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6pub enum MetaData {
7    UList,
8    OList,
9    PLanguage,
10    Other,
11    ColumnsCount,
12    Important,
13    Note,
14    Tip,
15    Warning,
16    Caution,
17    HeadingLevel(u8),
18}
19
20#[derive(Debug, Clone, Copy, PartialEq, Eq)]
21pub enum WordType {
22    Bold,
23    BoldItalic,
24    Code,
25    CodeBlock(Color),
26    Footnote,
27    FootnoteData,
28    FootnoteInline,
29    Italic,
30    Link,
31    LinkData,
32    ListMarker,
33    MetaInfo(MetaData),
34    Normal,
35    Selected,
36    Strikethrough,
37    White,
38}
39
40impl From<MdParseEnum> for WordType {
41    fn from(value: MdParseEnum) -> Self {
42        match value {
43            MdParseEnum::PLanguage
44            | MdParseEnum::BlockSeparator
45            | MdParseEnum::TaskOpen
46            | MdParseEnum::TaskClosed
47            | MdParseEnum::Indent
48            | MdParseEnum::HorizontalSeparator => WordType::MetaInfo(MetaData::Other),
49            MdParseEnum::FootnoteRef => WordType::FootnoteInline,
50            MdParseEnum::Code => WordType::Code,
51            MdParseEnum::Bold => WordType::Bold,
52            MdParseEnum::Italic => WordType::Italic,
53            MdParseEnum::Strikethrough => WordType::Strikethrough,
54            MdParseEnum::Link | MdParseEnum::WikiLink | MdParseEnum::InlineLink => WordType::Link,
55            MdParseEnum::BoldItalic => WordType::BoldItalic,
56            MdParseEnum::Digit => WordType::ListMarker,
57            MdParseEnum::Paragraph
58            | MdParseEnum::AltText
59            | MdParseEnum::Quote
60            | MdParseEnum::Sentence
61            | MdParseEnum::Word => WordType::Normal,
62            MdParseEnum::LinkData => WordType::LinkData,
63            MdParseEnum::Imortant => WordType::MetaInfo(MetaData::Important),
64            MdParseEnum::Note => WordType::MetaInfo(MetaData::Note),
65            MdParseEnum::Tip => WordType::MetaInfo(MetaData::Tip),
66            MdParseEnum::Warning => WordType::MetaInfo(MetaData::Warning),
67            MdParseEnum::Caution => WordType::MetaInfo(MetaData::Caution),
68            MdParseEnum::Heading
69            | MdParseEnum::BoldItalicStr
70            | MdParseEnum::BoldStr
71            | MdParseEnum::CodeBlock
72            | MdParseEnum::CodeStr
73            | MdParseEnum::Image
74            | MdParseEnum::ItalicStr
75            | MdParseEnum::ListContainer
76            | MdParseEnum::OrderedList
77            | MdParseEnum::StrikethroughStr
78            | MdParseEnum::Footnote
79            | MdParseEnum::Table
80            | MdParseEnum::TableCell
81            | MdParseEnum::Task
82            | MdParseEnum::UnorderedList
83            | MdParseEnum::TableSeparator => {
84                unreachable!("Edit this or pest file to fix for value: {:?}", value)
85            }
86            MdParseEnum::CodeBlockStr | MdParseEnum::CodeBlockStrSpaceIndented => {
87                WordType::CodeBlock(Color::Reset)
88            } // MdParseEnum::FootnoteRef => todo!(),
89        }
90    }
91}
92
93#[derive(Debug, Clone, PartialEq, Eq)]
94pub struct Word {
95    content: String,
96    word_type: WordType,
97    previous_type: Option<WordType>,
98}
99
100impl Word {
101    #[must_use]
102    pub fn new(content: String, word_type: WordType) -> Self {
103        Self {
104            word_type,
105            previous_type: None,
106            content,
107        }
108    }
109
110    #[must_use]
111    pub fn previous_type(&self) -> WordType {
112        self.previous_type.unwrap_or(self.word_type)
113    }
114
115    #[must_use]
116    pub fn content(&self) -> &str {
117        &self.content
118    }
119
120    pub fn content_mut(&mut self) -> &mut String {
121        &mut self.content
122    }
123
124    pub fn set_content(&mut self, content: impl Into<String>) {
125        self.content = content.into();
126    }
127
128    #[must_use]
129    pub fn kind(&self) -> WordType {
130        self.word_type
131    }
132
133    pub fn set_kind(&mut self, kind: WordType) {
134        self.previous_type = Some(self.word_type);
135        self.word_type = kind;
136    }
137
138    pub fn clear_kind(&mut self) {
139        self.word_type = self.previous_type.unwrap_or(self.word_type);
140        self.previous_type = None;
141    }
142
143    #[must_use]
144    pub fn is_renderable(&self) -> bool {
145        !matches!(
146            self.kind(),
147            WordType::MetaInfo(_) | WordType::LinkData | WordType::FootnoteData
148        )
149    }
150
151    pub fn split_off(&mut self, at: usize) -> Word {
152        Word {
153            content: self.content.split_off(at),
154            word_type: self.word_type,
155            previous_type: self.previous_type,
156        }
157    }
158}