Struct Table 

pub struct Table {
    pub start: usize,
    pub end: usize,
    pub lines: Vec<String>,
}

Fields

start: usize

First line index (0-based, inclusive).

end: usize

Last line index (inclusive).

lines: Vec<String>

Implementations

impl Table

pub fn header(&self) -> &str

pub fn delimiter(&self) -> &str

pub fn body(&self) -> &[String]

pub fn widths(&self) -> Vec<Vec<usize>>

Character count between pipes, per row. Equal vectors mean aligned.

Character count, not byte count. A byte count would read a multi-byte cell as wider than it prints, and since padding is emitted in characters the row would come out over-padded and the column ragged.

The corpus alone does not prove this: its aligned tables do hold non-ASCII cells, but only short ones (—, –) that are never the widest in their column, so the two counts agree everywhere it matters. bench/difftest.py adds a deliberately wide non-ASCII value for that reason – without it the byte-count mutation survives, which is how the gap was found (bench/mutate.py).

pub fn is_aligned(&self) -> bool

Examples found in repository

examples/oracle_cases.rs (line 381)

fn run(content: &str, op: &str, a: &Args) -> (&'static str, String) {
    match op {
        "py_repr" => {
            let text = a.get("text").map(String::as_str).unwrap_or("");
            match json::parse(text) {
                None => ("ok", "UNPARSED".to_string()),
                Some(v) => ("ok", json::py_repr(&v)),
            }
        }
        "check_args" => {
            let f = a.get("fn").map(String::as_str).unwrap_or("");
            let text = a.get("text").map(String::as_str).unwrap_or("");
            match arg_case(f, text) {
                Ok(s) => ("ok", s),
                Err(e) => ("err", e.message().to_string()),
            }
        }
        "render_table_list" => (
            "ok",
            render_table_list(content, a.get("path").map(String::as_str).unwrap_or("")),
        ),
        "list_tables" => {
            let dump = list_tables(content)
                .iter()
                .map(|e| {
                    format!(
                        "{}|{}|{}|{}|{}",
                        e.ordinal,
                        e.heading,
                        e.caption,
                        e.columns.join(" | "),
                        e.rows
                    )
                })
                .collect::<Vec<_>>()
                .join("\n");
            ("ok", dump)
        }
        "find_tables" => {
            let dump = find_tables(content)
                .iter()
                .map(|t| format!("{}|{}|{}|{}", t.start, t.end, t.is_aligned(), t.has_tabs()))
                .collect::<Vec<_>>()
                .join("\n");
            ("ok", dump)
        }
        "find_sections" => {
            let dump = find_sections(content)
                .iter()
                .map(|s| {
                    format!(
                        "{}|{}|{}|{}|{}|{}|{}|{}|{}|{}|{}|{}|{}|{}",
                        s.start,
                        s.heading_end,
                        s.own_end,
                        s.end,
                        s.level,
                        s.style.as_str(),
                        s.gap_after,
                        s.parent.map(|p| p as isize).unwrap_or(-1),
                        esc(&s.indent),
                        s.marker,
                        esc(&s.space),
                        s.closing,
                        esc(&s.raw_text),
                        s.path.join(" > ")
                    )
                })
                .collect::<Vec<_>>()
                .join("\n");
            ("ok", dump)
        }
        // The list parser, field by field, for the reason `find_sections` is
        // dumped: an op suite can agree everywhere and still be sitting on a
        // parser that disagrees about where a list ends. One line per list,
        // then one indented line per item -- `own_end` and `parent` are in
        // there because nothing else reads them, so nothing else would notice.
        "find_lists" => {
            let mut dump: Vec<String> = Vec::new();
            for l in find_lists(content) {
                dump.push(format!(
                    "{}|{}|{}|{}|{}|{}",
                    l.start,
                    l.end,
                    l.ordered,
                    l.bullet,
                    esc(&l.indent),
                    l.loose
                ));
                for it in &l.items {
                    dump.push(format!(
                        "  {}|{}|{}|{}|{}|{}|{}|{}|{}|{}|{}|{}",
                        it.start,
                        it.own_end,
                        it.end,
                        it.depth,
                        esc(&it.indent),
                        it.marker,
                        it.ordered,
                        opt(it.number.map(|n| n.to_string())),
                        opt(it.delim.map(|c| c.to_string())),
                        opt(it.checkbox.map(|c| c.to_string())),
                        it.parent.map(|p| p as isize).unwrap_or(-1),
                        esc(&it.text)
                    ));
                }
            }
            ("ok", dump.join("\n"))
        }
        // The frontmatter parser, field by field, for the reason the other two
        // are dumped -- plus `rebuilt()`, which no other dump has an analogue
        // for. Every edit in the family goes out through it, so comparing it
        // here catches a gap or padding divergence on a line no op in the suite
        // happens to rewrite.
        // `parse_path`, typed and round-tripped. Its own case op because the
        // parser only ever hands out paths it built itself, so the refusal
        // branch and the index arithmetic are reachable from no fixture.
        "parse_path" => match parse_path(a.get("text").map(String::as_str).unwrap_or("")) {
            None => ("ok", "NONE".to_string()),
            Some(p) => {
                let kinds = p
                    .iter()
                    .map(|s| match s {
                        Seg::Index(n) => format!("i:{n}"),
                        Seg::Key(k) => format!("k:{k}"),
                    })
                    .collect::<Vec<_>>()
                    .join("|");
                ("ok", format!("{}\n{kinds}", format_path(&p)))
            }
        },
        "find_frontmatter" => {
            let fm = find_frontmatter(content);
            if !fm.present {
                return ("ok", "absent".to_string());
            }
            let mut dump = vec![format!(
                "{}|{}|{}|{}|{}|{}",
                match fm.fmt {
                    Some(Fmt::Yaml) => "yaml",
                    _ => "toml",
                },
                fm.start,
                fm.end,
                fm.delim,
                fm.close,
                esc(&fm.eol)
            )];
            for e in &fm.entries {
                dump.push(format!(
                    "  {}|{}|{}|{}|{}|{}|{}|{}|{}|{}|{}|{}",
                    format_path(&e.path),
                    e.line,
                    e.end,
                    e.kind.as_str(),
                    esc(&e.prefix),
                    esc(&e.key_text),
                    esc(&e.gap),
                    esc(&e.value),
                    esc(&e.pad),
                    esc(&e.comment),
                    esc(&e.eol),
                    esc(&e.rebuilt(None))
                ));
            }
            ("ok", dump.join("\n"))
        }
        // `describe_change`'s case, for the family it does not describe. The
        // same shape deliberately: both sides apply the op and describe
        // before-vs-after, so a divergence in either half shows here.
        "describe_front" => {
            let name = a.get("opname").map(String::as_str).unwrap_or("");
            let arg = a.get("args").map(String::as_str).unwrap_or("ABSENT");
            let parsed = if arg == "ABSENT" {
                None
            } else {
                json::parse(arg)
            };
            if arg != "ABSENT" && parsed.is_none() {
                ("ok", format!("PARSE-FAILED {arg}"))
            } else {
                match apply_op(content, name, parsed.as_ref()) {
                    Ok(after) => ("ok", describe_frontmatter_change(content, &after)),
                    Err(e) => ("err", e.0),
                }
            }
        }
        "render_frontmatter" => (
            "ok",
            render_frontmatter(content, a.get("path").map(String::as_str).unwrap_or("")),
        ),
        // Through the rendered form for `render_table_get`'s reason — it is
        // what a model receives — and through the structure as well, because
        // that is what `keys --json` carries and `grade.py` scores. `state` and
        // `format` appear in neither rendering, so a port that got them wrong
        // would pass on the text alone.
        "frontmatter_get" => {
            let path = a.get("path").map(String::as_str).unwrap_or("");
            // Absent and an explicit `null` are the same call here, which is
            // the asymmetry with `frontmatter-set` the oracle spells with a
            // `key=None` default. Parsing gives `Value::Null` for the second
            // and the op filters it, so both arrive as no key.
            let key = match a.get("key") {
                None => None,
                Some(text) => match json::parse(text) {
                    Some(v) => Some(v),
                    None => return ("ok", format!("PARSE-FAILED {text}")),
                },
            };
            let got = match frontmatter_get(content, key.as_ref()) {
                Ok(g) => g,
                Err(e) => return ("err", e.0),
            };
            let text = match render_frontmatter_get(content, path, key.as_ref()) {
                Ok(t) => t,
                Err(e) => return ("err", e.0),
            };
            let mut dump = vec![format!(
                "{}|{}|{}",
                got.state,
                match got.format {
                    Some(Fmt::Yaml) => "yaml",
                    Some(Fmt::Toml) => "toml",
                    // Python's `None`, printed as an f-string prints it: the
                    // oracle's dict holds the parser's `fmt` unconverted, and
                    // an absent block has no format at all.
                    None => "None",
                },
                got.keys.len()
            )];
            for k in &got.keys {
                dump.push(format!(
                    "{}|{}|{}|{}",
                    k.path,
                    k.kind,
                    esc(&k.value),
                    k.lines
                ));
            }
            dump.push("--".to_string());
            dump.push(text);
            ("ok", dump.join("\n"))
        }
        // The list summary, field by field. The rendering is compared too, one
        // case below -- it is the Arm B prompt, so a divergence in it is a
        // divergence in what the model was measured on, not in a debug format.
        "list_lists" => {
            let dump = list_lists(content)
                .iter()
                .map(|e| {
                    format!(
                        "{}|{}|{}|{}|{}|{}|{}|{}",
                        e.ordinal, e.heading, e.kind, e.marker, e.items, e.levels, e.loose, e.tasks
                    )
                })
                .collect::<Vec<_>>()
                .join("\n");
            ("ok", dump)
        }
        "render_list_summary" => (
            "ok",
            render_list_summary(content, a.get("path").map(String::as_str).unwrap_or("")),
        ),
        // The section outline, field by field, and its rendering one case
        // below. The render is the section family's prompt context, so a
        // divergence in it is a divergence in what a model was measured on.
        "section_outline" => {
            let dump = section_outline(content)
                .iter()
                .map(|e| {
                    format!(
                        "{}|{}|{}|{}|{}|{}|{}|{}",
                        e.level,
                        e.path,
                        e.text,
                        e.style,
                        e.ordinal,
                        e.unique,
                        e.has_body,
                        e.subsections
                    )
                })
                .collect::<Vec<_>>()
                .join("\n");
            ("ok", dump)
        }
        "render_section_outline" => (
            "ok",
            render_section_outline(content, a.get("path").map(String::as_str).unwrap_or("")),
        ),
        // Three ends, not one: `own_end` and `end` are the field the ops
        // disagree about, so a resolver that found the right section with the
        // wrong subtree boundary would pass a `start`-only comparison.
        "resolve_section" => match resolve_section(content, &section_address(a)) {
            Ok(s) => (
                "ok",
                format!(
                    "{}|{}|{}|{}|{}",
                    s.start, s.heading_end, s.own_end, s.end, s.level
                ),
            ),
            Err(e) => ("err", e.0),
        },
        "resolve_list" => match resolve_list(content, &list_address(a)) {
            Ok(l) => ("ok", format!("{}|{}", l.start, l.end)),
            Err(e) => ("err", e.0),
        },
        "resolve_item" => match resolve_list(content, &list_address(a))
            .and_then(|l| resolve_item(&l, a.get("item").map(String::as_str), "item"))
        {
            Ok(i) => ("ok", i.to_string()),
            Err(e) => ("err", e.0),
        },
        "inert_headings" => {
            let dump = inert_headings(content)
                .iter()
                .map(|h| format!("{}|{}|{}", h.line, h.reason, h.text))
                .collect::<Vec<_>>()
                .join("\n");
            ("ok", dump)
        }
        "resolve_table" => match resolve_table(content, &address(a)) {
            Ok(t) => ("ok", format!("{}|{}", t.start, t.end)),
            Err(e) => ("err", e.0),
        },
        "resolve_row" => match resolve_table(content, &address(a))
            .and_then(|t| resolve_row(&t, &where_pairs(a)))
        {
            Ok(i) => ("ok", i.to_string()),
            Err(e) => ("err", e.0),
        },
        "add_row" => match table_add_row(content, &address(a), &values(a), position(a).as_ref()) {
            Ok(s) => ("ok", s),
            Err(e) => ("err", e.0),
        },
        "update_cell" => match table_update_cell(
            content,
            &address(a),
            &where_pairs(a),
            // Both raw, and both defaulted to "" -- the Python side passes
            // `args.get("column", "")` and `args.get("value", "")`, so an absent
            // argument is the empty string on this side too.
            Some(&json::Value::Str(
                a.get("column").cloned().unwrap_or_default(),
            )),
            Some(&json::Value::Str(
                a.get("value").cloned().unwrap_or_default(),
            )),
        ) {
            Ok(s) => ("ok", s),
            Err(e) => ("err", e.0),
        },
        // The read op, through its rendered form -- which is the whole result:
        // heading, matched/total counts, columns and every cell all appear in
        // the text, so comparing the render compares the struct behind it.
        // Comparing `TableRows` field by field would test a debug format that
        // no caller ever sees.
        "table_get" => {
            // Two wire formats, one op. The flat one is what every table case
            // uses; `args` is the typed hatch, and a case carrying it takes the
            // address from there too, or an untyped address would silently
            // override the typed one.
            let (addr, filt) = match typed_args(a) {
                Some(v) => (typed_address(v.get("table")), typed_filter(&v)),
                None => (address(a), filter_arg(a)),
            };
            match render_table_get(content, &addr, filt.as_ref()) {
                Ok(s) => ("ok", s),
                Err(e) => ("err", e.0),
            }
        }
        "delete_row" => match table_delete_row(content, &address(a), &where_pairs(a)) {
            Ok(s) => ("ok", s),
            Err(e) => ("err", e.0),
        },
        // The whole dispatch, arguments and all -- the op name and the raw
        // argument text, exactly as `difftest.py` hands them to `F.apply_op`.
        // What is compared is the message a model would actually receive, so
        // the argument-checking *order* (dispatch.rs's whole reason to exist)
        // is under test here and nowhere else.
        "apply_op" => {
            let name = a.get("opname").map(String::as_str).unwrap_or("");
            let text = a.get("args").map(String::as_str).unwrap_or("ABSENT");
            let parsed = if text == "ABSENT" {
                None
            } else {
                json::parse(text)
            };
            // Every DISPATCH_ARGS entry but `ABSENT` is valid JSON by
            // construction, so a `None` here is a `parse` bug. Saying so beats
            // passing `None` on and quietly testing the absent-argument path.
            if text != "ABSENT" && parsed.is_none() {
                ("ok", format!("PARSE-FAILED {text}"))
            } else {
                match apply_op(content, name, parsed.as_ref()) {
                    Ok(s) => ("ok", s),
                    Err(e) => ("err", e.0),
                }
            }
        }
        // `describe_change` needs two documents, and a case carries one
        // fixture. So it carries the *op* that produces the second: both sides
        // apply it and describe before-vs-after, which keeps the wire cheap and
        // reuses a document the corpus already vouches for. A refusal is
        // returned as itself — those messages are compared by the `apply_op`
        // family anyway, so nothing is lost and no case is wasted.
        //
        // `after` is the escape hatch for the branches no op reaches. It rides
        // as a JSON string because a raw newline would break the line-framed
        // case file, which is the same reason `apply_op` passes its arguments
        // that way.
        "describe_change" => {
            if let Some(text) = a.get("after") {
                return match json::parse(text) {
                    Some(json::Value::Str(s)) => ("ok", describe_change(content, &s)),
                    _ => ("ok", format!("PARSE-FAILED {text}")),
                };
            }
            let name = a.get("opname").map(String::as_str).unwrap_or("");
            let arg = a.get("args").map(String::as_str).unwrap_or("ABSENT");
            let parsed = if arg == "ABSENT" {
                None
            } else {
                json::parse(arg)
            };
            if arg != "ABSENT" && parsed.is_none() {
                ("ok", format!("PARSE-FAILED {arg}"))
            } else {
                match apply_op(content, name, parsed.as_ref()) {
                    Ok(after) => ("ok", describe_change(content, &after)),
                    Err(e) => ("err", e.0),
                }
            }
        }
        other => ("err", format!("unknown op {other}")),
    }
}

pub fn cells(&self, line: &str) -> Vec<String>

pub fn columns(&self) -> Vec<String>

pub fn rows(&self) -> Vec<Vec<String>>

pub fn has_tabs(&self) -> bool

True if any of the table’s lines contains a tab.

corpus/hazards/whitespace.md pads its cells with tabs. Those cells have equal character counts, so the alignment check reports aligned and the re-pad path rewrites every tab to spaces — a silent whitespace rewrite of lines nobody asked to touch. Character-count alignment is the only kind that can be maintained arithmetically; tab alignment depends on a tab stop this tool does not know. So a tab-containing table is treated as ragged, following §5.2’s rule that a table whose alignment cannot be verified counts as ragged.

Examples found in repository

examples/oracle_cases.rs (line 381)

fn run(content: &str, op: &str, a: &Args) -> (&'static str, String) {
    match op {
        "py_repr" => {
            let text = a.get("text").map(String::as_str).unwrap_or("");
            match json::parse(text) {
                None => ("ok", "UNPARSED".to_string()),
                Some(v) => ("ok", json::py_repr(&v)),
            }
        }
        "check_args" => {
            let f = a.get("fn").map(String::as_str).unwrap_or("");
            let text = a.get("text").map(String::as_str).unwrap_or("");
            match arg_case(f, text) {
                Ok(s) => ("ok", s),
                Err(e) => ("err", e.message().to_string()),
            }
        }
        "render_table_list" => (
            "ok",
            render_table_list(content, a.get("path").map(String::as_str).unwrap_or("")),
        ),
        "list_tables" => {
            let dump = list_tables(content)
                .iter()
                .map(|e| {
                    format!(
                        "{}|{}|{}|{}|{}",
                        e.ordinal,
                        e.heading,
                        e.caption,
                        e.columns.join(" | "),
                        e.rows
                    )
                })
                .collect::<Vec<_>>()
                .join("\n");
            ("ok", dump)
        }
        "find_tables" => {
            let dump = find_tables(content)
                .iter()
                .map(|t| format!("{}|{}|{}|{}", t.start, t.end, t.is_aligned(), t.has_tabs()))
                .collect::<Vec<_>>()
                .join("\n");
            ("ok", dump)
        }
        "find_sections" => {
            let dump = find_sections(content)
                .iter()
                .map(|s| {
                    format!(
                        "{}|{}|{}|{}|{}|{}|{}|{}|{}|{}|{}|{}|{}|{}",
                        s.start,
                        s.heading_end,
                        s.own_end,
                        s.end,
                        s.level,
                        s.style.as_str(),
                        s.gap_after,
                        s.parent.map(|p| p as isize).unwrap_or(-1),
                        esc(&s.indent),
                        s.marker,
                        esc(&s.space),
                        s.closing,
                        esc(&s.raw_text),
                        s.path.join(" > ")
                    )
                })
                .collect::<Vec<_>>()
                .join("\n");
            ("ok", dump)
        }
        // The list parser, field by field, for the reason `find_sections` is
        // dumped: an op suite can agree everywhere and still be sitting on a
        // parser that disagrees about where a list ends. One line per list,
        // then one indented line per item -- `own_end` and `parent` are in
        // there because nothing else reads them, so nothing else would notice.
        "find_lists" => {
            let mut dump: Vec<String> = Vec::new();
            for l in find_lists(content) {
                dump.push(format!(
                    "{}|{}|{}|{}|{}|{}",
                    l.start,
                    l.end,
                    l.ordered,
                    l.bullet,
                    esc(&l.indent),
                    l.loose
                ));
                for it in &l.items {
                    dump.push(format!(
                        "  {}|{}|{}|{}|{}|{}|{}|{}|{}|{}|{}|{}",
                        it.start,
                        it.own_end,
                        it.end,
                        it.depth,
                        esc(&it.indent),
                        it.marker,
                        it.ordered,
                        opt(it.number.map(|n| n.to_string())),
                        opt(it.delim.map(|c| c.to_string())),
                        opt(it.checkbox.map(|c| c.to_string())),
                        it.parent.map(|p| p as isize).unwrap_or(-1),
                        esc(&it.text)
                    ));
                }
            }
            ("ok", dump.join("\n"))
        }
        // The frontmatter parser, field by field, for the reason the other two
        // are dumped -- plus `rebuilt()`, which no other dump has an analogue
        // for. Every edit in the family goes out through it, so comparing it
        // here catches a gap or padding divergence on a line no op in the suite
        // happens to rewrite.
        // `parse_path`, typed and round-tripped. Its own case op because the
        // parser only ever hands out paths it built itself, so the refusal
        // branch and the index arithmetic are reachable from no fixture.
        "parse_path" => match parse_path(a.get("text").map(String::as_str).unwrap_or("")) {
            None => ("ok", "NONE".to_string()),
            Some(p) => {
                let kinds = p
                    .iter()
                    .map(|s| match s {
                        Seg::Index(n) => format!("i:{n}"),
                        Seg::Key(k) => format!("k:{k}"),
                    })
                    .collect::<Vec<_>>()
                    .join("|");
                ("ok", format!("{}\n{kinds}", format_path(&p)))
            }
        },
        "find_frontmatter" => {
            let fm = find_frontmatter(content);
            if !fm.present {
                return ("ok", "absent".to_string());
            }
            let mut dump = vec![format!(
                "{}|{}|{}|{}|{}|{}",
                match fm.fmt {
                    Some(Fmt::Yaml) => "yaml",
                    _ => "toml",
                },
                fm.start,
                fm.end,
                fm.delim,
                fm.close,
                esc(&fm.eol)
            )];
            for e in &fm.entries {
                dump.push(format!(
                    "  {}|{}|{}|{}|{}|{}|{}|{}|{}|{}|{}|{}",
                    format_path(&e.path),
                    e.line,
                    e.end,
                    e.kind.as_str(),
                    esc(&e.prefix),
                    esc(&e.key_text),
                    esc(&e.gap),
                    esc(&e.value),
                    esc(&e.pad),
                    esc(&e.comment),
                    esc(&e.eol),
                    esc(&e.rebuilt(None))
                ));
            }
            ("ok", dump.join("\n"))
        }
        // `describe_change`'s case, for the family it does not describe. The
        // same shape deliberately: both sides apply the op and describe
        // before-vs-after, so a divergence in either half shows here.
        "describe_front" => {
            let name = a.get("opname").map(String::as_str).unwrap_or("");
            let arg = a.get("args").map(String::as_str).unwrap_or("ABSENT");
            let parsed = if arg == "ABSENT" {
                None
            } else {
                json::parse(arg)
            };
            if arg != "ABSENT" && parsed.is_none() {
                ("ok", format!("PARSE-FAILED {arg}"))
            } else {
                match apply_op(content, name, parsed.as_ref()) {
                    Ok(after) => ("ok", describe_frontmatter_change(content, &after)),
                    Err(e) => ("err", e.0),
                }
            }
        }
        "render_frontmatter" => (
            "ok",
            render_frontmatter(content, a.get("path").map(String::as_str).unwrap_or("")),
        ),
        // Through the rendered form for `render_table_get`'s reason — it is
        // what a model receives — and through the structure as well, because
        // that is what `keys --json` carries and `grade.py` scores. `state` and
        // `format` appear in neither rendering, so a port that got them wrong
        // would pass on the text alone.
        "frontmatter_get" => {
            let path = a.get("path").map(String::as_str).unwrap_or("");
            // Absent and an explicit `null` are the same call here, which is
            // the asymmetry with `frontmatter-set` the oracle spells with a
            // `key=None` default. Parsing gives `Value::Null` for the second
            // and the op filters it, so both arrive as no key.
            let key = match a.get("key") {
                None => None,
                Some(text) => match json::parse(text) {
                    Some(v) => Some(v),
                    None => return ("ok", format!("PARSE-FAILED {text}")),
                },
            };
            let got = match frontmatter_get(content, key.as_ref()) {
                Ok(g) => g,
                Err(e) => return ("err", e.0),
            };
            let text = match render_frontmatter_get(content, path, key.as_ref()) {
                Ok(t) => t,
                Err(e) => return ("err", e.0),
            };
            let mut dump = vec![format!(
                "{}|{}|{}",
                got.state,
                match got.format {
                    Some(Fmt::Yaml) => "yaml",
                    Some(Fmt::Toml) => "toml",
                    // Python's `None`, printed as an f-string prints it: the
                    // oracle's dict holds the parser's `fmt` unconverted, and
                    // an absent block has no format at all.
                    None => "None",
                },
                got.keys.len()
            )];
            for k in &got.keys {
                dump.push(format!(
                    "{}|{}|{}|{}",
                    k.path,
                    k.kind,
                    esc(&k.value),
                    k.lines
                ));
            }
            dump.push("--".to_string());
            dump.push(text);
            ("ok", dump.join("\n"))
        }
        // The list summary, field by field. The rendering is compared too, one
        // case below -- it is the Arm B prompt, so a divergence in it is a
        // divergence in what the model was measured on, not in a debug format.
        "list_lists" => {
            let dump = list_lists(content)
                .iter()
                .map(|e| {
                    format!(
                        "{}|{}|{}|{}|{}|{}|{}|{}",
                        e.ordinal, e.heading, e.kind, e.marker, e.items, e.levels, e.loose, e.tasks
                    )
                })
                .collect::<Vec<_>>()
                .join("\n");
            ("ok", dump)
        }
        "render_list_summary" => (
            "ok",
            render_list_summary(content, a.get("path").map(String::as_str).unwrap_or("")),
        ),
        // The section outline, field by field, and its rendering one case
        // below. The render is the section family's prompt context, so a
        // divergence in it is a divergence in what a model was measured on.
        "section_outline" => {
            let dump = section_outline(content)
                .iter()
                .map(|e| {
                    format!(
                        "{}|{}|{}|{}|{}|{}|{}|{}",
                        e.level,
                        e.path,
                        e.text,
                        e.style,
                        e.ordinal,
                        e.unique,
                        e.has_body,
                        e.subsections
                    )
                })
                .collect::<Vec<_>>()
                .join("\n");
            ("ok", dump)
        }
        "render_section_outline" => (
            "ok",
            render_section_outline(content, a.get("path").map(String::as_str).unwrap_or("")),
        ),
        // Three ends, not one: `own_end` and `end` are the field the ops
        // disagree about, so a resolver that found the right section with the
        // wrong subtree boundary would pass a `start`-only comparison.
        "resolve_section" => match resolve_section(content, &section_address(a)) {
            Ok(s) => (
                "ok",
                format!(
                    "{}|{}|{}|{}|{}",
                    s.start, s.heading_end, s.own_end, s.end, s.level
                ),
            ),
            Err(e) => ("err", e.0),
        },
        "resolve_list" => match resolve_list(content, &list_address(a)) {
            Ok(l) => ("ok", format!("{}|{}", l.start, l.end)),
            Err(e) => ("err", e.0),
        },
        "resolve_item" => match resolve_list(content, &list_address(a))
            .and_then(|l| resolve_item(&l, a.get("item").map(String::as_str), "item"))
        {
            Ok(i) => ("ok", i.to_string()),
            Err(e) => ("err", e.0),
        },
        "inert_headings" => {
            let dump = inert_headings(content)
                .iter()
                .map(|h| format!("{}|{}|{}", h.line, h.reason, h.text))
                .collect::<Vec<_>>()
                .join("\n");
            ("ok", dump)
        }
        "resolve_table" => match resolve_table(content, &address(a)) {
            Ok(t) => ("ok", format!("{}|{}", t.start, t.end)),
            Err(e) => ("err", e.0),
        },
        "resolve_row" => match resolve_table(content, &address(a))
            .and_then(|t| resolve_row(&t, &where_pairs(a)))
        {
            Ok(i) => ("ok", i.to_string()),
            Err(e) => ("err", e.0),
        },
        "add_row" => match table_add_row(content, &address(a), &values(a), position(a).as_ref()) {
            Ok(s) => ("ok", s),
            Err(e) => ("err", e.0),
        },
        "update_cell" => match table_update_cell(
            content,
            &address(a),
            &where_pairs(a),
            // Both raw, and both defaulted to "" -- the Python side passes
            // `args.get("column", "")` and `args.get("value", "")`, so an absent
            // argument is the empty string on this side too.
            Some(&json::Value::Str(
                a.get("column").cloned().unwrap_or_default(),
            )),
            Some(&json::Value::Str(
                a.get("value").cloned().unwrap_or_default(),
            )),
        ) {
            Ok(s) => ("ok", s),
            Err(e) => ("err", e.0),
        },
        // The read op, through its rendered form -- which is the whole result:
        // heading, matched/total counts, columns and every cell all appear in
        // the text, so comparing the render compares the struct behind it.
        // Comparing `TableRows` field by field would test a debug format that
        // no caller ever sees.
        "table_get" => {
            // Two wire formats, one op. The flat one is what every table case
            // uses; `args` is the typed hatch, and a case carrying it takes the
            // address from there too, or an untyped address would silently
            // override the typed one.
            let (addr, filt) = match typed_args(a) {
                Some(v) => (typed_address(v.get("table")), typed_filter(&v)),
                None => (address(a), filter_arg(a)),
            };
            match render_table_get(content, &addr, filt.as_ref()) {
                Ok(s) => ("ok", s),
                Err(e) => ("err", e.0),
            }
        }
        "delete_row" => match table_delete_row(content, &address(a), &where_pairs(a)) {
            Ok(s) => ("ok", s),
            Err(e) => ("err", e.0),
        },
        // The whole dispatch, arguments and all -- the op name and the raw
        // argument text, exactly as `difftest.py` hands them to `F.apply_op`.
        // What is compared is the message a model would actually receive, so
        // the argument-checking *order* (dispatch.rs's whole reason to exist)
        // is under test here and nowhere else.
        "apply_op" => {
            let name = a.get("opname").map(String::as_str).unwrap_or("");
            let text = a.get("args").map(String::as_str).unwrap_or("ABSENT");
            let parsed = if text == "ABSENT" {
                None
            } else {
                json::parse(text)
            };
            // Every DISPATCH_ARGS entry but `ABSENT` is valid JSON by
            // construction, so a `None` here is a `parse` bug. Saying so beats
            // passing `None` on and quietly testing the absent-argument path.
            if text != "ABSENT" && parsed.is_none() {
                ("ok", format!("PARSE-FAILED {text}"))
            } else {
                match apply_op(content, name, parsed.as_ref()) {
                    Ok(s) => ("ok", s),
                    Err(e) => ("err", e.0),
                }
            }
        }
        // `describe_change` needs two documents, and a case carries one
        // fixture. So it carries the *op* that produces the second: both sides
        // apply it and describe before-vs-after, which keeps the wire cheap and
        // reuses a document the corpus already vouches for. A refusal is
        // returned as itself — those messages are compared by the `apply_op`
        // family anyway, so nothing is lost and no case is wasted.
        //
        // `after` is the escape hatch for the branches no op reaches. It rides
        // as a JSON string because a raw newline would break the line-framed
        // case file, which is the same reason `apply_op` passes its arguments
        // that way.
        "describe_change" => {
            if let Some(text) = a.get("after") {
                return match json::parse(text) {
                    Some(json::Value::Str(s)) => ("ok", describe_change(content, &s)),
                    _ => ("ok", format!("PARSE-FAILED {text}")),
                };
            }
            let name = a.get("opname").map(String::as_str).unwrap_or("");
            let arg = a.get("args").map(String::as_str).unwrap_or("ABSENT");
            let parsed = if arg == "ABSENT" {
                None
            } else {
                json::parse(arg)
            };
            if arg != "ABSENT" && parsed.is_none() {
                ("ok", format!("PARSE-FAILED {arg}"))
            } else {
                match apply_op(content, name, parsed.as_ref()) {
                    Ok(after) => ("ok", describe_change(content, &after)),
                    Err(e) => ("err", e.0),
                }
            }
        }
        other => ("err", format!("unknown op {other}")),
    }
}

Trait Implementations

impl Clone for Table

fn clone(&self) -> Table

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Table

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Table

impl PartialEq for Table

fn eq(&self, other: &Table) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Table