use std::path::Path;
use anyhow::{Context, Result};
use serde::{Deserialize, Serialize};
use crate::theme::ThemeConfig;
#[derive(Debug)]
pub struct Deck {
pub title: String,
pub columns: Vec<Column>,
}
#[derive(Debug)]
pub struct Column {
pub slides: Vec<Slide>,
}
#[derive(Debug)]
pub struct Slide {
pub title: String,
pub segments: Vec<Segment>,
pub notes: String,
pub theme: Option<crate::theme::ThemeConfig>,
}
#[derive(Debug)]
pub enum Segment {
Markdown(String),
Terminal(TermBlock),
Qr(QrBlock),
Image(ImageBlock),
Row(Vec<Vec<Segment>>),
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct QrBlock {
pub data: String,
pub rows: Vec<String>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ImageBlock {
pub path: String,
pub alt: String,
pub data: Option<crate::ascii_image::ImageData>,
pub error: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TermBlock {
pub id: usize,
pub command: Option<String>,
pub rows: u16,
pub fill: bool,
pub snapshot: Option<TermSnapshot>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TermSnapshot {
pub cols: u16,
pub rows: u16,
pub data: Vec<u8>,
}
impl Deck {
pub fn slide(&self, col: usize, row: usize) -> &Slide {
&self.columns[col].slides[row]
}
pub fn terminal_commands(&self) -> Vec<String> {
self.columns
.iter()
.flat_map(|c| &c.slides)
.flat_map(|s| s.leaf_segments())
.filter_map(|seg| match seg {
Segment::Terminal(b) => Some(
b.command
.as_deref()
.and_then(|c| c.lines().next())
.unwrap_or("shell")
.to_string(),
),
_ => None,
})
.collect()
}
pub fn terminals_mut(&mut self) -> Vec<&mut TermBlock> {
fn walk<'s>(segments: &'s mut [Segment], out: &mut Vec<&'s mut TermBlock>) {
for seg in segments {
match seg {
Segment::Terminal(b) => out.push(b),
Segment::Row(cells) => {
for cell in cells {
walk(cell, out);
}
}
_ => {}
}
}
}
let mut out = Vec::new();
for column in &mut self.columns {
for slide in &mut column.slides {
walk(&mut slide.segments, &mut out);
}
}
out
}
#[cfg(not(target_arch = "wasm32"))]
pub fn resolve_images(&mut self, base: &Path) {
fn walk(segments: &mut [Segment], base: &Path) {
for seg in segments {
match seg {
Segment::Image(img) if img.data.is_none() => {
match crate::ascii_image::load(&base.join(&img.path)) {
Ok(data) => img.data = Some(data),
Err(e) => img.error = Some(format!("{e:#}")),
}
}
Segment::Row(cells) => {
for cell in cells {
walk(cell, base);
}
}
_ => {}
}
}
}
for column in &mut self.columns {
for slide in &mut column.slides {
walk(&mut slide.segments, base);
}
}
}
pub fn image_paths(&self) -> Vec<&str> {
self.columns
.iter()
.flat_map(|c| &c.slides)
.flat_map(|s| s.leaf_segments())
.filter_map(|seg| match seg {
Segment::Image(img) => Some(img.path.as_str()),
_ => None,
})
.collect()
}
pub fn flat(&self) -> Vec<(usize, usize)> {
let mut out = Vec::new();
for (c, col) in self.columns.iter().enumerate() {
for r in 0..col.slides.len() {
out.push((c, r));
}
}
out
}
}
impl Slide {
pub fn term_ids(&self) -> Vec<usize> {
self.leaf_segments()
.filter_map(|s| match s {
Segment::Terminal(b) => Some(b.id),
_ => None,
})
.collect()
}
pub fn leaf_segments(&self) -> impl Iterator<Item = &Segment> {
self.segments.iter().flat_map(|seg| match seg {
Segment::Row(cells) => {
Box::new(cells.iter().flatten()) as Box<dyn Iterator<Item = &Segment>>
}
other => Box::new(std::iter::once(other)),
})
}
}
pub fn load(path: &Path) -> Result<(Deck, Option<ThemeConfig>)> {
if path.extension().and_then(|e| e.to_str()) == Some("json") {
return crate::config::load(path);
}
let source = std::fs::read_to_string(path)
.with_context(|| format!("reading deck file {}", path.display()))?;
let fallback = path
.file_stem()
.map(|s| s.to_string_lossy().into_owned())
.unwrap_or_else(|| "deck".to_string());
let (deck, theme) = parse_full(&source, &fallback)?;
if deck.columns.is_empty() {
anyhow::bail!("deck {} contains no slides", path.display());
}
Ok((deck, theme))
}
#[derive(Debug, Default, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct FrontMatter {
#[serde(skip_serializing_if = "Option::is_none")]
pub title: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub theme: Option<ThemeConfig>,
}
pub fn parse_full(source: &str, fallback_title: &str) -> Result<(Deck, Option<ThemeConfig>)> {
let mut theme = None;
let mut title = None;
let body = match split_frontmatter(source) {
Some((raw, rest)) => match serde_yaml::from_str::<serde_yaml::Value>(&raw) {
Ok(serde_yaml::Value::Mapping(_)) => {
let fm: FrontMatter = serde_yaml::from_str(&raw)
.context("parsing deck frontmatter (supported keys: title, theme)")?;
theme = fm.theme;
title = fm.title;
rest
}
_ => source.to_string(),
},
None => source.to_string(),
};
let mut deck = parse(&body, fallback_title)?;
if let Some(t) = title {
deck.title = t;
}
Ok((deck, theme))
}
fn split_frontmatter(source: &str) -> Option<(String, String)> {
let mut iter = source.split_inclusive('\n');
let first = iter.next()?;
if first.trim_end() != "---" {
return None;
}
let mut fm = String::new();
let mut consumed = first.len();
for line in iter {
consumed += line.len();
if line.trim_end() == "---" {
return Some((fm, source[consumed..].to_string()));
}
fm.push_str(line);
}
None
}
pub fn parse(source: &str, title: &str) -> Result<Deck> {
let mut next_term_id = 0usize;
let mut columns = Vec::new();
for (c, sources) in split_source(source).into_iter().enumerate() {
let mut slides = Vec::new();
for (r, src) in sources.into_iter().enumerate() {
slides.push(parse_slide(&src, c, r, &mut next_term_id)?);
}
columns.push(Column { slides });
}
Ok(Deck {
title: title.to_string(),
columns,
})
}
pub(crate) type Fence = Option<(char, usize)>;
pub(crate) fn opens_fence(trimmed: &str) -> Fence {
let ch = trimmed.chars().next()?;
if ch != '`' && ch != '~' {
return None;
}
let n = trimmed.chars().take_while(|c| *c == ch).count();
if n >= 3 { Some((ch, n)) } else { None }
}
pub(crate) fn closes_fence(trimmed: &str, ch: char, len: usize) -> bool {
!trimmed.is_empty() && trimmed.chars().all(|c| c == ch) && trimmed.chars().count() >= len
}
fn split_source(source: &str) -> Vec<Vec<String>> {
let mut columns: Vec<Vec<String>> = Vec::new();
let mut column: Vec<String> = Vec::new();
let mut cur = String::new();
let mut fence: Fence = None;
for line in source.lines() {
let t = line.trim();
if let Some((ch, n)) = fence {
cur.push_str(line);
cur.push('\n');
if closes_fence(t, ch, n) {
fence = None;
}
continue;
}
if let Some(f) = opens_fence(t) {
fence = Some(f);
cur.push_str(line);
cur.push('\n');
continue;
}
if t.len() >= 2 && t.chars().all(|c| c == '-') {
column.push(std::mem::take(&mut cur));
if t.len() >= 3 {
columns.push(std::mem::take(&mut column));
}
continue;
}
cur.push_str(line);
cur.push('\n');
}
column.push(cur);
columns.push(column);
columns
.into_iter()
.map(|col| {
col.into_iter()
.filter(|s| !s.trim().is_empty())
.collect::<Vec<_>>()
})
.filter(|col| !col.is_empty())
.collect()
}
pub fn parse_slide(src: &str, col: usize, row: usize, next_term_id: &mut usize) -> Result<Slide> {
let mut body = String::new();
let mut notes = String::new();
let mut in_notes = false;
let mut fence: Fence = None;
for line in src.lines() {
let t = line.trim();
match fence {
Some((ch, n)) => {
if closes_fence(t, ch, n) {
fence = None;
}
}
None => {
if let Some(f) = opens_fence(t) {
fence = Some(f);
} else if t == "???" && !in_notes {
in_notes = true;
continue;
}
}
}
let target = if in_notes { &mut notes } else { &mut body };
target.push_str(line);
target.push('\n');
}
let (segments, theme) = parse_segments(&body, next_term_id)
.with_context(|| format!("slide {}.{}", col + 1, row + 1))?;
let title = extract_title(&body).unwrap_or_else(|| format!("{}.{}", col + 1, row + 1));
Ok(Slide {
title,
segments,
notes: notes.trim().to_string(),
theme,
})
}
enum Pending {
Term(TermBlock, String),
Theme(String),
Qr(String),
Row(String),
}
fn split_cells(body: &str) -> Vec<String> {
let mut cells = vec![String::new()];
let mut fence: Fence = None;
for line in body.lines() {
let t = line.trim();
match fence {
Some((ch, n)) => {
if closes_fence(t, ch, n) {
fence = None;
}
}
None => {
if let Some(f) = opens_fence(t) {
fence = Some(f);
} else if t.len() >= 2 && t.chars().all(|c| c == '|') {
cells.push(String::new());
continue;
}
}
}
let cell = cells.last_mut().expect("starts non-empty");
cell.push_str(line);
cell.push('\n');
}
cells
}
fn parse_row(
body: &str,
next_term_id: &mut usize,
) -> Result<(Vec<Vec<Segment>>, Option<ThemeConfig>)> {
let mut cells = Vec::new();
let mut theme: Option<ThemeConfig> = None;
for cell_src in split_cells(body) {
if cell_src.trim().is_empty() {
continue;
}
let (segments, cell_theme) =
parse_segments_at(&cell_src, next_term_id, false).context("in `row` fence cell")?;
if let Some(cfg) = cell_theme {
theme = Some(match theme.take() {
Some(prev) => prev.merged(cfg),
None => cfg,
});
}
if !segments.is_empty() {
cells.push(segments);
}
}
if cells.len() < 2 {
anyhow::bail!(
"a `row` fence needs at least two non-empty cells separated by a `||` line \
(and an outer fence longer than any fence inside the cells, e.g. ````row)"
);
}
Ok((cells, theme))
}
fn image_line(t: &str) -> Option<(String, String)> {
let rest = t.strip_prefix("?;
let inner = rest.strip_suffix(')')?;
if inner.contains(')') {
return None;
}
let path = match inner.split_once(" \"") {
Some((p, _title)) => p,
None => inner,
}
.trim();
(!path.is_empty()).then(|| (alt.to_string(), path.to_string()))
}
fn parse_segments(
body: &str,
next_term_id: &mut usize,
) -> Result<(Vec<Segment>, Option<ThemeConfig>)> {
parse_segments_at(body, next_term_id, true)
}
fn parse_segments_at(
body: &str,
next_term_id: &mut usize,
allow_rows: bool,
) -> Result<(Vec<Segment>, Option<ThemeConfig>)> {
let mut segments = Vec::new();
let mut theme: Option<ThemeConfig> = None;
let mut md = String::new();
let mut fence: Fence = None;
let mut pending: Option<Pending> = None;
let flush_md = |md: &mut String, segments: &mut Vec<Segment>| {
if !md.trim().is_empty() {
segments.push(Segment::Markdown(std::mem::take(md)));
} else {
md.clear();
}
};
let finish_term = |block: &mut TermBlock, tbody: &str| -> Result<()> {
use base64::Engine as _;
let mut command = String::new();
let mut dims: Option<(u16, u16)> = None;
let mut b64 = String::new();
for line in tbody.lines() {
if dims.is_none() {
if let Some(rest) = line.trim().strip_prefix("%%snapshot") {
let (c, r) = rest
.trim()
.split_once('x')
.context("`%%snapshot` header needs COLSxROWS")?;
dims = Some((
c.trim().parse().context("snapshot cols")?,
r.trim().parse().context("snapshot rows")?,
));
} else {
command.push_str(line);
command.push('\n');
}
} else {
b64.push_str(line.trim());
}
}
let script = command.trim();
block.command = (!script.is_empty()).then(|| script.to_string());
if let Some((cols, rows)) = dims {
let data = base64::engine::general_purpose::STANDARD
.decode(b64.as_bytes())
.context("decoding `%%snapshot` data")?;
block.snapshot = Some(TermSnapshot { cols, rows, data });
}
Ok(())
};
let merge_theme = |theme: &mut Option<ThemeConfig>, tbody: &str| -> Result<()> {
let cfg: ThemeConfig = serde_yaml::from_str(tbody).context("parsing `theme` block")?;
*theme = Some(match theme.take() {
Some(prev) => prev.merged(cfg),
None => cfg,
});
Ok(())
};
let finish_qr = |qbody: &str| -> Result<QrBlock> {
let data = qbody.trim().to_string();
if data.is_empty() {
anyhow::bail!("`qr` block is empty — put a URL or text inside the fence");
}
let rows = crate::qr::encode(&data).context("in `qr` block")?;
Ok(QrBlock { data, rows })
};
for line in body.lines() {
let t = line.trim();
if let Some((ch, n)) = fence {
if closes_fence(t, ch, n) {
fence = None;
match pending.take() {
Some(Pending::Term(mut block, tbody)) => {
finish_term(&mut block, &tbody)?;
flush_md(&mut md, &mut segments);
segments.push(Segment::Terminal(block));
}
Some(Pending::Theme(tbody)) => merge_theme(&mut theme, &tbody)?,
Some(Pending::Qr(qbody)) => {
flush_md(&mut md, &mut segments);
segments.push(Segment::Qr(finish_qr(&qbody)?));
}
Some(Pending::Row(rbody)) => {
let (cells, row_theme) = parse_row(&rbody, next_term_id)?;
if let Some(cfg) = row_theme {
theme = Some(match theme.take() {
Some(prev) => prev.merged(cfg),
None => cfg,
});
}
flush_md(&mut md, &mut segments);
segments.push(Segment::Row(cells));
}
None => {
md.push_str(line);
md.push('\n');
}
}
} else if let Some(
Pending::Term(_, tbody)
| Pending::Theme(tbody)
| Pending::Qr(tbody)
| Pending::Row(tbody),
) = pending.as_mut()
{
tbody.push_str(line);
tbody.push('\n');
} else {
md.push_str(line);
md.push('\n');
}
continue;
}
if let Some(f) = opens_fence(t) {
fence = Some(f);
let info = t.trim_start_matches(['`', '~']).trim();
let mut words = info.split_whitespace();
match words.next() {
Some("terminal") => {
let mut rows: u16 = 12;
let mut fill = false;
for w in words {
if let Some(v) = w.strip_prefix("rows=") {
if v == "fill" {
fill = true;
} else {
rows = v.parse().unwrap_or(12);
}
}
}
let id = *next_term_id;
*next_term_id += 1;
pending = Some(Pending::Term(
TermBlock {
id,
command: None,
rows: rows.clamp(3, 40),
fill,
snapshot: None,
},
String::new(),
));
}
Some("theme") => pending = Some(Pending::Theme(String::new())),
Some("qr") => pending = Some(Pending::Qr(String::new())),
Some("row") if allow_rows => pending = Some(Pending::Row(String::new())),
Some("row") => anyhow::bail!("`row` fences can't nest"),
_ => {
md.push_str(line);
md.push('\n');
}
}
continue;
}
if let Some((alt, path)) = image_line(t) {
flush_md(&mut md, &mut segments);
segments.push(Segment::Image(ImageBlock {
path,
alt,
data: None,
error: None,
}));
continue;
}
md.push_str(line);
md.push('\n');
}
match pending.take() {
Some(Pending::Term(mut block, tbody)) => {
finish_term(&mut block, &tbody)?;
flush_md(&mut md, &mut segments);
segments.push(Segment::Terminal(block));
}
Some(Pending::Theme(tbody)) => merge_theme(&mut theme, &tbody)?,
Some(Pending::Qr(qbody)) => {
flush_md(&mut md, &mut segments);
segments.push(Segment::Qr(finish_qr(&qbody)?));
}
Some(Pending::Row(rbody)) => {
let (cells, row_theme) = parse_row(&rbody, next_term_id)?;
if let Some(cfg) = row_theme {
theme = Some(match theme.take() {
Some(prev) => prev.merged(cfg),
None => cfg,
});
}
flush_md(&mut md, &mut segments);
segments.push(Segment::Row(cells));
}
None => {}
}
flush_md(&mut md, &mut segments);
Ok((segments, theme))
}
fn extract_title(body: &str) -> Option<String> {
let mut fence: Fence = None;
let mut first_text: Option<String> = None;
for line in body.lines() {
let t = line.trim();
if let Some((ch, n)) = fence {
if closes_fence(t, ch, n) {
fence = None;
}
continue;
}
if let Some(f) = opens_fence(t) {
fence = Some(f);
continue;
}
if t.starts_with('#') {
let title = t.trim_start_matches('#').trim();
if !title.is_empty() {
return Some(title.to_string());
}
}
if first_text.is_none() && !t.is_empty() {
let cleaned: String = t
.trim_start_matches(['>', '-', '*', ' '])
.chars()
.take(48)
.collect();
if !cleaned.is_empty() {
first_text = Some(cleaned);
}
}
}
first_text
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn columns_and_depth() {
let deck = parse("# a\n---\n# b\n--\n# b2\n---\n# c\n", "t").unwrap();
assert_eq!(deck.columns.len(), 3);
assert_eq!(deck.columns[0].slides.len(), 1);
assert_eq!(deck.columns[1].slides.len(), 2);
assert_eq!(deck.columns[1].slides[1].title, "b2");
assert_eq!(deck.flat().len(), 4);
}
#[test]
fn separators_inside_fences_are_ignored() {
let deck = parse("# one\n```\n---\n--\n```\nafter\n", "t").unwrap();
assert_eq!(deck.columns.len(), 1);
assert_eq!(deck.columns[0].slides.len(), 1);
match &deck.columns[0].slides[0].segments[0] {
Segment::Markdown(md) => assert!(md.contains("---")),
_ => panic!("expected markdown segment"),
}
}
#[test]
fn notes_split() {
let deck = parse("# a\nvisible\n???\nsecret note\nmore\n", "t").unwrap();
let slide = deck.slide(0, 0);
assert_eq!(slide.notes, "secret note\nmore");
match &slide.segments[0] {
Segment::Markdown(md) => {
assert!(md.contains("visible"));
assert!(!md.contains("secret"));
}
_ => panic!(),
}
}
#[test]
fn terminal_block() {
let deck = parse("# a\nbefore\n```terminal rows=8\nhtop\n```\nafter\n", "t").unwrap();
let slide = deck.slide(0, 0);
assert_eq!(slide.segments.len(), 3);
match &slide.segments[1] {
Segment::Terminal(b) => {
assert_eq!(b.command.as_deref(), Some("htop"));
assert_eq!(b.rows, 8);
assert_eq!(b.id, 0);
}
_ => panic!("expected terminal segment"),
}
}
#[test]
fn terminal_snapshot_parses() {
let deck = parse(
"```terminal rows=4\nhtop\n%%snapshot 80x4\naGk=\n```\n",
"t",
)
.unwrap();
match &deck.slide(0, 0).segments[0] {
Segment::Terminal(b) => {
assert_eq!(b.command.as_deref(), Some("htop"));
let snap = b.snapshot.as_ref().unwrap();
assert_eq!((snap.cols, snap.rows), (80, 4));
assert_eq!(snap.data, b"hi");
}
_ => panic!("expected terminal"),
}
}
#[test]
fn bad_snapshot_header_errors() {
assert!(parse("```terminal\n%%snapshot nope\n```\n", "t").is_err());
}
#[test]
fn empty_terminal_block_is_shell() {
let deck = parse("```terminal\n```\n", "t").unwrap();
match &deck.slide(0, 0).segments[0] {
Segment::Terminal(b) => assert!(b.command.is_none()),
_ => panic!(),
}
}
#[test]
fn slide_theme_block() {
let deck = parse(
"# a\n```theme\nmargin: 0\naccent: red\n```\nbody\n---\n# b\n",
"t",
)
.unwrap();
let slide = deck.slide(0, 0);
let theme = slide.theme.as_ref().unwrap();
assert_eq!(theme.margin, Some(0));
match &slide.segments[0] {
Segment::Markdown(md) => assert!(!md.contains("margin")),
_ => panic!(),
}
assert!(deck.slide(1, 0).theme.is_none());
}
#[test]
fn bad_slide_theme_block_errors() {
let err = parse("# a\n```theme\nbogus_key: 1\n```\n", "t").unwrap_err();
assert!(format!("{err:#}").contains("slide 1.1"));
}
#[test]
fn frontmatter_theme_and_title() {
let src = "---\ntitle: my talk\ntheme:\n accent: magenta\n max_width: 80\n---\n\n# a\n---\n# b\n";
let (deck, theme) = parse_full(src, "fallback").unwrap();
assert_eq!(deck.title, "my talk");
assert_eq!(deck.columns.len(), 2);
let theme = theme.unwrap();
assert_eq!(theme.max_width, Some(80));
let resolved = crate::theme::Theme::resolve(vec![theme]).unwrap();
assert_eq!(resolved.accent, ratatui::style::Color::Magenta);
}
#[test]
fn no_frontmatter_is_unchanged() {
let (deck, theme) = parse_full("# a\nhello\n", "fallback").unwrap();
assert!(theme.is_none());
assert_eq!(deck.title, "fallback");
assert_eq!(deck.columns.len(), 1);
}
#[test]
fn non_mapping_leading_block_stays_content() {
let src = "---\njust some text\n---\nreal slide\n";
let (deck, theme) = parse_full(src, "fallback").unwrap();
assert!(theme.is_none());
assert_eq!(deck.columns.len(), 2);
}
#[test]
fn bad_frontmatter_errors() {
let src = "---\ntitle: x\nbogus_key: 1\n---\n# a\n";
assert!(parse_full(src, "fallback").is_err());
}
#[test]
fn qr_block() {
let deck = parse("# a\n```qr\nhttps://deckhand.sh\n```\nafter\n", "t").unwrap();
let slide = deck.slide(0, 0);
match &slide.segments[1] {
Segment::Qr(q) => {
assert_eq!(q.data, "https://deckhand.sh");
assert!(q.rows.len() > 10);
}
other => panic!("expected qr segment, got {other:?}"),
}
}
#[test]
fn empty_qr_block_errors() {
let err = parse("# a\n```qr\n```\n", "t").unwrap_err();
assert!(format!("{err:#}").contains("slide 1.1"));
}
#[test]
fn image_line_becomes_segment() {
let deck = parse("# a\nbefore\n\nafter\n", "t").unwrap();
let slide = deck.slide(0, 0);
assert_eq!(slide.segments.len(), 3);
match &slide.segments[1] {
Segment::Image(img) => {
assert_eq!(img.path, "plan.png");
assert_eq!(img.alt, "the plan");
assert!(img.data.is_none());
}
other => panic!("expected image segment, got {other:?}"),
}
}
#[test]
fn image_title_is_dropped() {
let deck = parse("\n", "t").unwrap();
match &deck.slide(0, 0).segments[0] {
Segment::Image(img) => assert_eq!(img.path, "p.png"),
_ => panic!(),
}
}
#[test]
fn image_inside_fence_stays_markdown() {
let deck = parse("```\n\n```\n", "t").unwrap();
match &deck.slide(0, 0).segments[0] {
Segment::Markdown(md) => assert!(md.contains("")),
_ => panic!("expected markdown segment"),
}
}
#[test]
fn inline_image_stays_markdown() {
let deck = parse("see  here\n", "t").unwrap();
assert_eq!(deck.slide(0, 0).segments.len(), 1);
assert!(matches!(deck.slide(0, 0).segments[0], Segment::Markdown(_)));
}
#[test]
fn missing_image_resolves_to_error() {
let mut deck = parse("\n", "t").unwrap();
deck.resolve_images(Path::new("/nonexistent-base"));
match &deck.slide(0, 0).segments[0] {
Segment::Image(img) => {
assert!(img.data.is_none());
assert!(img.error.as_deref().unwrap().contains("does-not-exist"));
}
_ => panic!(),
}
}
#[test]
fn row_fence_splits_cells() {
let src = "# a\n````row\nleft *md*\n||\n```qr\nhi\n```\n||\nright\n````\nafter\n";
let deck = parse(src, "t").unwrap();
let slide = deck.slide(0, 0);
assert_eq!(slide.segments.len(), 3);
match &slide.segments[1] {
Segment::Row(cells) => {
assert_eq!(cells.len(), 3);
assert!(matches!(cells[0][0], Segment::Markdown(_)));
assert!(matches!(cells[1][0], Segment::Qr(_)));
assert!(matches!(cells[2][0], Segment::Markdown(_)));
}
other => panic!("expected row, got {other:?}"),
}
}
#[test]
fn row_cells_hold_terminals_with_global_ids() {
let src = "```terminal\n```\n````row\n```terminal\nhtop\n```\n||\ntext\n````\n";
let deck = parse(src, "t").unwrap();
assert_eq!(deck.slide(0, 0).term_ids(), vec![0, 1]);
assert_eq!(deck.terminal_commands(), vec!["shell", "htop"]);
}
#[test]
fn row_needs_two_cells() {
let err = parse("```row\nonly one cell\n```\n", "t").unwrap_err();
assert!(format!("{err:#}").contains("two"));
}
#[test]
fn rows_cannot_nest() {
let src = "`````row\n````row\na\n||\nb\n````\n||\nc\n`````\n";
let err = parse(src, "t").unwrap_err();
assert!(format!("{err:#}").contains("nest"));
}
#[test]
fn pipes_inside_cell_code_fences_stay_content() {
let src = "````row\n```\n||\n```\n||\nright\n````\n";
let deck = parse(src, "t").unwrap();
match &deck.slide(0, 0).segments[0] {
Segment::Row(cells) => {
assert_eq!(cells.len(), 2);
match &cells[0][0] {
Segment::Markdown(md) => assert!(md.contains("||")),
_ => panic!(),
}
}
_ => panic!("expected row"),
}
}
#[test]
fn term_ids_are_global() {
let deck = parse("```terminal\n```\n---\n```terminal\n```\n", "t").unwrap();
assert_eq!(deck.slide(0, 0).term_ids(), vec![0]);
assert_eq!(deck.slide(1, 0).term_ids(), vec![1]);
}
}