1use crate::html_element::HtmlElement;
2use crate::markdown_writer::{HandleTag, HandlerOutcome, MarkdownWriter, StartTagOutcome};
3
4pub struct WebpageChromeRemover;
5
6impl HandleTag for WebpageChromeRemover {
7 fn should_handle(&self, tag: &str) -> bool {
8 matches!(tag, "head" | "script" | "style" | "nav")
9 }
10
11 fn handle_tag_start(
12 &mut self,
13 tag: &HtmlElement,
14 _writer: &mut MarkdownWriter,
15 ) -> StartTagOutcome {
16 match tag.tag() {
17 "head" | "script" | "style" | "nav" => return StartTagOutcome::Skip,
18 _ => {}
19 }
20
21 StartTagOutcome::Continue
22 }
23}
24
25pub struct ParagraphHandler;
26
27impl HandleTag for ParagraphHandler {
28 fn should_handle(&self, _tag: &str) -> bool {
29 true
30 }
31
32 fn handle_tag_start(
33 &mut self,
34 tag: &HtmlElement,
35 writer: &mut MarkdownWriter,
36 ) -> StartTagOutcome {
37 if tag.is_inline()
38 && writer.is_inside("p")
39 && let Some(parent) = writer.current_element_stack().iter().last()
40 && !(parent.is_inline()
41 || writer.markdown.ends_with(' ')
42 || writer.markdown.ends_with('\n'))
43 {
44 writer.push_str(" ");
45 }
46
47 if tag.tag() == "p" {
48 writer.push_blank_line()
49 }
50 StartTagOutcome::Continue
51 }
52}
53
54pub struct HeadingHandler;
55
56impl HandleTag for HeadingHandler {
57 fn should_handle(&self, tag: &str) -> bool {
58 matches!(tag, "h1" | "h2" | "h3" | "h4" | "h5" | "h6")
59 }
60
61 fn handle_tag_start(
62 &mut self,
63 tag: &HtmlElement,
64 writer: &mut MarkdownWriter,
65 ) -> StartTagOutcome {
66 match tag.tag() {
67 "h1" => writer.push_str("\n\n# "),
68 "h2" => writer.push_str("\n\n## "),
69 "h3" => writer.push_str("\n\n### "),
70 "h4" => writer.push_str("\n\n#### "),
71 "h5" => writer.push_str("\n\n##### "),
72 "h6" => writer.push_str("\n\n###### "),
73 _ => {}
74 }
75
76 StartTagOutcome::Continue
77 }
78
79 fn handle_tag_end(&mut self, tag: &HtmlElement, writer: &mut MarkdownWriter) {
80 match tag.tag() {
81 "h1" | "h2" | "h3" | "h4" | "h5" | "h6" => writer.push_blank_line(),
82 _ => {}
83 }
84 }
85}
86
87pub struct ListHandler;
88
89impl HandleTag for ListHandler {
90 fn should_handle(&self, tag: &str) -> bool {
91 matches!(tag, "ul" | "ol" | "li")
92 }
93
94 fn handle_tag_start(
95 &mut self,
96 tag: &HtmlElement,
97 writer: &mut MarkdownWriter,
98 ) -> StartTagOutcome {
99 match tag.tag() {
100 "ul" | "ol" => writer.push_newline(),
101 "li" => writer.push_str("- "),
102 _ => {}
103 }
104
105 StartTagOutcome::Continue
106 }
107
108 fn handle_tag_end(&mut self, tag: &HtmlElement, writer: &mut MarkdownWriter) {
109 match tag.tag() {
110 "ul" | "ol" => writer.push_newline(),
111 "li" => writer.push_newline(),
112 _ => {}
113 }
114 }
115}
116
117pub struct TableHandler {
118 /// The number of columns in the current `<table>`.
119 current_table_columns: usize,
120 is_first_th: bool,
121 is_first_td: bool,
122}
123
124impl TableHandler {
125 pub fn new() -> Self {
126 Self {
127 current_table_columns: 0,
128 is_first_th: true,
129 is_first_td: true,
130 }
131 }
132}
133
134impl Default for TableHandler {
135 fn default() -> Self {
136 Self::new()
137 }
138}
139
140impl HandleTag for TableHandler {
141 fn should_handle(&self, tag: &str) -> bool {
142 matches!(tag, "table" | "thead" | "tbody" | "tr" | "th" | "td")
143 }
144
145 fn handle_tag_start(
146 &mut self,
147 tag: &HtmlElement,
148 writer: &mut MarkdownWriter,
149 ) -> StartTagOutcome {
150 match tag.tag() {
151 "thead" => writer.push_blank_line(),
152 "tr" => writer.push_newline(),
153 "th" => {
154 self.current_table_columns += 1;
155 if self.is_first_th {
156 self.is_first_th = false;
157 } else {
158 writer.push_str(" ");
159 }
160 writer.push_str("| ");
161 }
162 "td" => {
163 if self.is_first_td {
164 self.is_first_td = false;
165 } else {
166 writer.push_str(" ");
167 }
168 writer.push_str("| ");
169 }
170 _ => {}
171 }
172
173 StartTagOutcome::Continue
174 }
175
176 fn handle_tag_end(&mut self, tag: &HtmlElement, writer: &mut MarkdownWriter) {
177 match tag.tag() {
178 "thead" => {
179 writer.push_newline();
180 for ix in 0..self.current_table_columns {
181 if ix > 0 {
182 writer.push_str(" ");
183 }
184 writer.push_str("| ---");
185 }
186 writer.push_str(" |");
187 self.is_first_th = true;
188 }
189 "tr" => {
190 writer.push_str(" |");
191 self.is_first_td = true;
192 }
193 "table" => {
194 self.current_table_columns = 0;
195 }
196 _ => {}
197 }
198 }
199}
200
201pub struct StyledTextHandler;
202
203impl HandleTag for StyledTextHandler {
204 fn should_handle(&self, tag: &str) -> bool {
205 matches!(tag, "strong" | "em")
206 }
207
208 fn handle_tag_start(
209 &mut self,
210 tag: &HtmlElement,
211 writer: &mut MarkdownWriter,
212 ) -> StartTagOutcome {
213 match tag.tag() {
214 "strong" => writer.push_str("**"),
215 "em" => writer.push_str("_"),
216 _ => {}
217 }
218
219 StartTagOutcome::Continue
220 }
221
222 fn handle_tag_end(&mut self, tag: &HtmlElement, writer: &mut MarkdownWriter) {
223 match tag.tag() {
224 "strong" => writer.push_str("**"),
225 "em" => writer.push_str("_"),
226 _ => {}
227 }
228 }
229}
230
231pub struct CodeHandler;
232
233impl HandleTag for CodeHandler {
234 fn should_handle(&self, tag: &str) -> bool {
235 matches!(tag, "pre" | "code")
236 }
237
238 fn handle_tag_start(
239 &mut self,
240 tag: &HtmlElement,
241 writer: &mut MarkdownWriter,
242 ) -> StartTagOutcome {
243 match tag.tag() {
244 "code" => {
245 if !writer.is_inside("pre") {
246 writer.push_str("`");
247 }
248 }
249 "pre" => writer.push_str("\n\n```\n"),
250 _ => {}
251 }
252
253 StartTagOutcome::Continue
254 }
255
256 fn handle_tag_end(&mut self, tag: &HtmlElement, writer: &mut MarkdownWriter) {
257 match tag.tag() {
258 "code" => {
259 if !writer.is_inside("pre") {
260 writer.push_str("`");
261 }
262 }
263 "pre" => writer.push_str("\n```\n"),
264 _ => {}
265 }
266 }
267
268 fn handle_text(&mut self, text: &str, writer: &mut MarkdownWriter) -> HandlerOutcome {
269 if writer.is_inside("pre") {
270 writer.push_str(text);
271 return HandlerOutcome::Handled;
272 }
273
274 HandlerOutcome::NoOp
275 }
276}