| 1 | use std::io::Write; |
| 2 | |
| 3 | use crate::theme::{RESET |
| 4 | |
| 5 | pub struct MarkdownStream |
| 6 | out: W |
| 7 | cols: usize |
| 8 | in_code: bool |
| 9 | line: String |
| 10 | theme: Theme |
| 11 | } |
| 12 | |
| 13 | impl<W: Write |
| 14 | pub fn new( |
| 15 | MarkdownStream { |
| 16 | out, |
| 17 | cols: cols.max |
| 18 | in_code: false, |
| 19 | line: String |
| 20 | theme, |
| 21 | } |
| 22 | } |
| 23 | |
| 24 | pub fn set_theme( |
| 25 | self.theme = theme |
| 26 | } |
| 27 | |
| 28 | pub fn feed( |
| 29 | for c in strip_ansi |
| 30 | match c { |
| 31 | '\n' => { |
| 32 | let line = |
| 33 | self.emit_line(&line |
| 34 | } |
| 35 | '\r' => {} |
| 36 | '\t' => self |
| 37 | c => self. |
| 38 | } |
| 39 | } |
| 40 | self.out.flush() |
| 41 | Ok(()) |
| 42 | } |
| 43 | |
| 44 | pub fn finish( |
| 45 | if !self.line. |
| 46 | let line = |
| 47 | self.emit_line(&line |
| 48 | } |
| 49 | self.out.flush() |
| 50 | Ok(()) |
| 51 | } |
| 52 | |
| 53 | /// True when an in-progress line exists that `render_partial` can show. |
| 54 | pub fn has_partial( |
| 55 | !self.line.is_empty |
| 56 | } |
| 57 | |
| 58 | /// Render the current in-progress line styled for its context, WITHOUT |
| 59 | /// mutating any state (fences/headings re-style correctly when the line |
| 60 | /// completes and `emit_line` takes over). The caller owns replacing the |
| 61 | /// previous partial render, so a streamed line reads character-by-character |
| 62 | /// instead of popping in whole only when a newline lands. Exactly one line |
| 63 | /// is written, matching the one-line invariant of `emit_line`. |
| 64 | pub fn render_partial( |
| 65 | let line = |
| 66 | if line.is_empty() |
| 67 | return Ok(()); |
| 68 | } |
| 69 | if self.in_code { |
| 70 | return self.wln( |
| 71 | } |
| 72 | let indent = |
| 73 | let t = |
| 74 | if let Some |
| 75 | return self.wln( |
| 76 | "{}{}{}{}", |
| 77 | " ".repeat(indent |
| 78 | self.theme.md_orange, |
| 79 | inline(&rest, |
| 80 | RESET |
| 81 | )); |
| 82 | } |
| 83 | if let Some |
| 84 | return self.wln( |
| 85 | "{}{}• {}{}", |
| 86 | " ".repeat(indent |
| 87 | self.theme.md_accent, |
| 88 | inline(rest, & |
| 89 | RESET |
| 90 | )); |
| 91 | } |
| 92 | if let Some |
| 93 | return self.wln( |
| 94 | "{}{}{}. {}{}", |
| 95 | " ".repeat(indent |
| 96 | self.theme.md_accent, |
| 97 | num, |
| 98 | inline(rest, & |
| 99 | RESET |
| 100 | )); |
| 101 | } |
| 102 | if let Some |
| 103 | return self.wln( |
| 104 | "{}{}> {}{}", |
| 105 | " ".repeat(indent |
| 106 | self.theme.md_gray, |
| 107 | rest, |
| 108 | RESET |
| 109 | )); |
| 110 | } |
| 111 | self.wln(&format! |
| 112 | "{}{}{}", |
| 113 | self.theme.md_text, |
| 114 | inline(line, & |
| 115 | RESET |
| 116 | )) |
| 117 | } |
| 118 | |
| 119 | pub fn text( |
| 120 | self.feed(text |
| 121 | self.finish() |
| 122 | } |
| 123 | |
| 124 | pub fn output( |
| 125 | &self.out |
| 126 | } |
| 127 | |
| 128 | pub fn output_mut( |
| 129 | &mut self.out |
| 130 | } |
| 131 | |
| 132 | pub fn set_cols( |
| 133 | self.cols = cols |
| 134 | } |
| 135 | |
| 136 | fn wln(&mut |
| 137 | write!(self.out |
| 138 | } |
| 139 | |
| 140 | fn border(&mut |
| 141 | self.wln(&format! |
| 142 | "{}{}{}", |
| 143 | self.theme.md_gray, |
| 144 | "─".repeat(self |
| 145 | RESET |
| 146 | )) |
| 147 | } |
| 148 | |
| 149 | fn emit_line(&mut |
| 150 | let line = |
| 151 | if self.in_code { |
| 152 | let t = |
| 153 | if t.starts_with( |
| 154 | self.in_code = false; |
| 155 | return self.border(); |
| 156 | } |
| 157 | if line.is_empty() |
| 158 | return self.wln( |
| 159 | } |
| 160 | return self.wln( |
| 161 | } |
| 162 | let indent = |
| 163 | let t = |
| 164 | if t.starts_with( |
| 165 | self.in_code = true; |
| 166 | return self.border(); |
| 167 | } |
| 168 | if is_hr(t) |
| 169 | return self.wln( |
| 170 | "{}{}{}", |
| 171 | self.theme.md_gray, |
| 172 | "─".repeat(self |
| 173 | RESET |
| 174 | )); |
| 175 | } |
| 176 | if let Some |
| 177 | return self.wln( |
| 178 | "{}{}{}{}", |
| 179 | " ".repeat(indent |
| 180 | self.theme.md_orange, |
| 181 | inline(&rest, |
| 182 | RESET |
| 183 | )); |
| 184 | } |
| 185 | if let Some |
| 186 | return self.wln( |
| 187 | "{}{}• {}{}", |
| 188 | " ".repeat(indent |
| 189 | self.theme.md_accent, |
| 190 | inline(rest, & |
| 191 | RESET |
| 192 | )); |
| 193 | } |
| 194 | if let Some |
| 195 | return self.wln( |
| 196 | "{}{}{}. {}{}", |
| 197 | " ".repeat(indent |
| 198 | self.theme.md_accent, |
| 199 | num, |
| 200 | inline(rest, & |
| 201 | RESET |
| 202 | )); |
| 203 | } |
| 204 | if let Some |
| 205 | return self.wln( |
| 206 | "{}{}> {}{}", |
| 207 | " ".repeat(indent |
| 208 | self.theme.md_gray, |
| 209 | rest, |
| 210 | RESET |
| 211 | )); |
| 212 | } |
| 213 | if line.is_empty() |
| 214 | return self.wln( |
| 215 | } |
| 216 | self.wln(&format! |
| 217 | "{}{}{}", |
| 218 | self.theme.md_text, |
| 219 | inline(line, & |
| 220 | RESET |
| 221 | )) |
| 222 | } |
| 223 | } |
| 224 | |
| 225 | pub(crate) fn strip_ansi |
| 226 | let mut out |
| 227 | let mut chars |
| 228 | while let Some |
| 229 | if c == ' |
| 230 | for d in chars |
| 231 | if d.is_ascii_alphabetic() |
| 232 | break; |
| 233 | } |
| 234 | } |
| 235 | } else { |
| 236 | out.push(c |
| 237 | } |
| 238 | } |
| 239 | out |
| 240 | } |
| 241 | |
| 242 | fn is_hr(t: |
| 243 | t.chars().count |
| 244 | } |
| 245 | |
| 246 | fn heading(t: |
| 247 | let n = |
| 248 | if n == 0 |
| 249 | return None; |
| 250 | } |
| 251 | let rest = |
| 252 | if !rest.starts_with |
| 253 | return None; |
| 254 | } |
| 255 | Some(rest. |
| 256 | } |
| 257 | |
| 258 | fn bullet(t: |
| 259 | for p in [ |
| 260 | if let Some |
| 261 | return Some(r |
| 262 | } |
| 263 | } |
| 264 | None |
| 265 | } |
| 266 | |
| 267 | fn numbered(t: |
| 268 | let bytes = |
| 269 | let mut i |
| 270 | while i < bytes |
| 271 | i += 1; |
| 272 | } |
| 273 | if i == 0 |
| 274 | return None; |
| 275 | } |
| 276 | Some((t[ |
| 277 | } |
| 278 | |
| 279 | fn quote(t: |
| 280 | if let Some |
| 281 | Some(r. |
| 282 | } else { |
| 283 | None |
| 284 | } |
| 285 | } |
| 286 | |
| 287 | fn find(chars: |
| 288 | (from..chars.len |
| 289 | } |
| 290 | |
| 291 | fn find_seq(chars: |
| 292 | if from + seq |
| 293 | return None; |
| 294 | } |
| 295 | (from..=chars.len |
| 296 | } |
| 297 | |
| 298 | fn inline(s: |
| 299 | let chars: Vec |
| 300 | let n = |
| 301 | let mut out |
| 302 | let mut i |
| 303 | while i < n |
| 304 | let c = |
| 305 | if c == ' |
| 306 | out.push(chars |
| 307 | i += 2; |
| 308 | continue; |
| 309 | } |
| 310 | if c == ' |
| 311 | if let Some |
| 312 | let inner: String |
| 313 | out.push_str("\ |
| 314 | out.push_str(&inline |
| 315 | out.push_str(RESET |
| 316 | out.push_str(&theme |
| 317 | out.push_str(base |
| 318 | i = j |
| 319 | continue; |
| 320 | } |
| 321 | out.push_str("** |
| 322 | i += 2; |
| 323 | continue; |
| 324 | } |
| 325 | if c == ' |
| 326 | if let Some |
| 327 | let inner: String |
| 328 | out.push_str(&theme |
| 329 | out.push_str(&inner |
| 330 | out.push_str(RESET |
| 331 | out.push_str(&theme |
| 332 | out.push_str(base |
| 333 | i = j |
| 334 | continue; |
| 335 | } |
| 336 | out.push('` |
| 337 | i += 1; |
| 338 | continue; |
| 339 | } |
| 340 | if c == ' |
| 341 | if let Some |
| 342 | let inner: String |
| 343 | out.push_str("\ |
| 344 | out.push_str(&inline |
| 345 | out.push_str(RESET |
| 346 | out.push_str(&theme |
| 347 | out.push_str(base |
| 348 | i = j |
| 349 | continue; |
| 350 | } |
| 351 | out.push('* |
| 352 | i += 1; |
| 353 | continue; |
| 354 | } |
| 355 | if c == ' |
| 356 | if let Some |
| 357 | && close + 1 |
| 358 | && chars[close |
| 359 | && let Some |
| 360 | { |
| 361 | let label: String |
| 362 | let url: String |
| 363 | out.push_str(&theme |
| 364 | out.push_str(&inline |
| 365 | out.push_str(RESET |
| 366 | out.push_str(&theme |
| 367 | out.push_str(base |
| 368 | out.push_str(&theme |
| 369 | out.push_str(&format! |
| 370 | out.push_str(RESET |
| 371 | out.push_str(&theme |
| 372 | out.push_str(base |
| 373 | i = end |
| 374 | continue; |
| 375 | } |
| 376 | out.push('[ |
| 377 | i += 1; |
| 378 | continue; |
| 379 | } |
| 380 | out.push(c |
| 381 | i += 1; |
| 382 | } |
| 383 | out |
| 384 | } |
| 385 | |
| 386 | #[cfg(test)] |
| 387 | mod tests { |
| 388 | use super::*; |
| 389 | |
| 390 | fn render(text: |
| 391 | let mut buf |
| 392 | let mut md |
| 393 | md.text(text |
| 394 | String::from_utf8( |
| 395 | } |
| 396 | |
| 397 | #[test] |
| 398 | fn strips_ansi_from_input() { |
| 399 | assert_eq!(strip_ansi( |
| 400 | } |
| 401 | |
| 402 | #[test] |
| 403 | fn plain_text_passes_through() { |
| 404 | let out = |
| 405 | assert!(out.contains |
| 406 | } |
| 407 | |
| 408 | #[test] |
| 409 | fn crlf_newlines() { |
| 410 | let out = |
| 411 | assert!(out.contains |
| 412 | assert!(!out. |
| 413 | } |
| 414 | |
| 415 | #[test] |
| 416 | fn bold_and_code() { |
| 417 | let out = |
| 418 | assert!(out.contains |
| 419 | assert!(out.contains |
| 420 | } |
| 421 | |
| 422 | #[test] |
| 423 | fn spans_restore_bg_and_base_after_reset() { |
| 424 | let out = |
| 425 | assert!(out.contains |
| 426 | let out = |
| 427 | assert!(out.contains |
| 428 | "\x1b[38;2;138;190;183mcode\x1b[0m\x1b |
| 429 | )); |
| 430 | } |
| 431 | |
| 432 | #[test] |
| 433 | fn heading() { |
| 434 | let out = |
| 435 | assert!(out.contains |
| 436 | } |
| 437 | |
| 438 | #[test] |
| 439 | fn code_block_bordered() { |
| 440 | let out = |
| 441 | assert_eq!(out.matches |
| 442 | assert!(out.contains |
| 443 | } |
| 444 | |
| 445 | #[test] |
| 446 | fn bullet_and_numbered() { |
| 447 | let out = |
| 448 | assert!(out.contains |
| 449 | assert!(out.contains |
| 450 | } |
| 451 | |
| 452 | #[test] |
| 453 | fn quote_and_hr() { |
| 454 | let out = |
| 455 | assert!(out.contains |
| 456 | assert!(out.contains |
| 457 | } |
| 458 | } |