stryke/

format.rs

//! Perl `format` / `write` — picture lines and field padding (subset of Perl 5 `perlform`).

use crate::ast::Expr;
use crate::error::{StrykeError, StrykeResult};
use crate::parser::parse_format_value_line;

/// Parsed `format NAME = ... .` body (after registration).
#[derive(Debug, Clone)]
pub struct FormatTemplate {
    /// `records` field.
    pub records: Vec<FormatRecord>,
}
/// `FormatRecord` — see variants.
#[derive(Debug, Clone)]
pub enum FormatRecord {
    /// Line with no `@` fields — printed as-is (newline added by `write`).
    Literal(String),
    /// Picture line with `@…` fields plus the following value line (comma-separated exprs).
    Picture {
        segments: Vec<PictureSegment>,
        exprs: Vec<Expr>,
    },
}
/// `FieldAlign` — see variants.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum FieldAlign {
    /// `Left` variant.
    Left,
    /// `Right` variant.
    Right,
    /// `Center` variant.
    Center,
    /// `Numeric` variant.
    Numeric,
    /// `Multiline` variant.
    Multiline,
}
/// `FieldKind` — see variants.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum FieldKind {
    /// `Text` variant.
    Text,
    /// `Numeric` variant.
    Numeric,
    /// `Multiline` variant.
    Multiline,
}
/// `PictureSegment` — see variants.
#[derive(Debug, Clone)]
pub enum PictureSegment {
    /// `Literal` variant.
    Literal(String),
    /// `Field` variant.
    Field {
        width: usize,
        align: FieldAlign,
        kind: FieldKind,
    },
}

/// Build a template from raw lines between `format N =` and `.`.
pub fn parse_format_template(lines: &[String]) -> StrykeResult<FormatTemplate> {
    let mut records = Vec::new();
    let mut i = 0;
    while i < lines.len() {
        let pic_line = &lines[i];
        if !pic_line.contains('@') {
            records.push(FormatRecord::Literal(pic_line.clone()));
            i += 1;
            continue;
        }
        let segments = parse_picture_segments(pic_line)?;
        let n_fields = segments
            .iter()
            .filter(|s| matches!(s, PictureSegment::Field { .. }))
            .count();
        i += 1;
        if i >= lines.len() {
            return Err(StrykeError::syntax(
                "picture line with @ fields must be followed by a value line",
                0,
            ));
        }
        let exprs = parse_format_value_line(&lines[i])?;
        if exprs.len() != n_fields {
            return Err(StrykeError::syntax(
                format!(
                    "format: {} picture field(s) but {} value expression(s)",
                    n_fields,
                    exprs.len()
                ),
                0,
            ));
        }
        records.push(FormatRecord::Picture { segments, exprs });
        i += 1;
    }
    Ok(FormatTemplate { records })
}

fn parse_picture_segments(pic: &str) -> StrykeResult<Vec<PictureSegment>> {
    let mut out = Vec::new();
    let mut lit = String::new();
    let mut chars = pic.chars().peekable();
    while let Some(c) = chars.next() {
        if c == '@' {
            if chars.peek() == Some(&'@') {
                chars.next();
                lit.push('@');
                continue;
            }
            if !lit.is_empty() {
                out.push(PictureSegment::Literal(std::mem::take(&mut lit)));
            }
            // width starts at 1 because `@` itself counts as one column
            let mut width = 1usize;
            let align = match chars.peek() {
                Some('<') => {
                    while chars.peek() == Some(&'<') {
                        chars.next();
                        width += 1;
                    }
                    FieldAlign::Left
                }
                Some('>') => {
                    while chars.peek() == Some(&'>') {
                        chars.next();
                        width += 1;
                    }
                    FieldAlign::Right
                }
                Some('|') => {
                    while chars.peek() == Some(&'|') {
                        chars.next();
                        width += 1;
                    }
                    FieldAlign::Center
                }
                Some('#') => {
                    while chars.peek() == Some(&'#') {
                        chars.next();
                        width += 1;
                    }
                    FieldAlign::Numeric
                }
                Some('*') => {
                    while chars.peek() == Some(&'*') {
                        chars.next();
                        width += 1;
                    }
                    FieldAlign::Multiline
                }
                _ => {
                    width = 1;
                    FieldAlign::Left
                }
            };
            let kind = match align {
                FieldAlign::Numeric => FieldKind::Numeric,
                FieldAlign::Multiline => FieldKind::Multiline,
                _ => FieldKind::Text,
            };
            out.push(PictureSegment::Field { width, align, kind });
        } else {
            lit.push(c);
        }
    }
    if !lit.is_empty() {
        out.push(PictureSegment::Literal(lit));
    }
    Ok(out)
}

/// Pad/truncate a value to `width` display columns (character count).
pub fn pad_field(s: &str, width: usize, align: FieldAlign) -> String {
    let s = if s.chars().count() > width {
        s.chars().take(width).collect::<String>()
    } else {
        s.to_string()
    };
    let len = s.chars().count();
    match align {
        FieldAlign::Left => {
            let pad = width.saturating_sub(len);
            format!("{}{}", s, " ".repeat(pad))
        }
        FieldAlign::Multiline => {
            let first = s.lines().next().unwrap_or("");
            let fl = first.chars().count();
            let t = if fl > width {
                first.chars().take(width).collect::<String>()
            } else {
                first.to_string()
            };
            let pad = width.saturating_sub(t.chars().count());
            format!("{}{}", t, " ".repeat(pad))
        }
        FieldAlign::Right => {
            let pad = width.saturating_sub(len);
            format!("{}{}", " ".repeat(pad), s)
        }
        FieldAlign::Center => {
            let pad = width.saturating_sub(len);
            let left = pad / 2;
            let right = pad - left;
            format!("{}{}{}", " ".repeat(left), s, " ".repeat(right))
        }
        FieldAlign::Numeric => {
            if let Ok(n) = s.parse::<i64>() {
                format!("{n:>width$}", n = n, width = width)
            } else if let Ok(f) = s.parse::<f64>() {
                format!("{f:>width$}", f = f, width = width)
            } else {
                let pad = width.saturating_sub(len);
                format!("{}{}", " ".repeat(pad), s)
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn parse_format_template_empty() {
        let t = parse_format_template(&[]).expect("parse");
        assert!(t.records.is_empty());
    }

    #[test]
    fn parse_format_template_literal_only() {
        let t = parse_format_template(&["no fields here".to_string()]).expect("parse");
        assert_eq!(t.records.len(), 1);
        assert!(matches!(
            &t.records[0],
            FormatRecord::Literal(s) if s == "no fields here"
        ));
    }

    #[test]
    fn parse_format_template_picture_and_value_line() {
        let t =
            parse_format_template(&["@<<<<".to_string(), r#"qq(ab)"#.to_string()]).expect("parse");
        assert_eq!(t.records.len(), 1);
        let FormatRecord::Picture { segments, exprs } = &t.records[0] else {
            panic!("expected picture");
        };
        assert_eq!(exprs.len(), 1);
        assert_eq!(segments.len(), 1);
        assert!(matches!(
            &segments[0],
            PictureSegment::Field {
                width: 5,
                align: FieldAlign::Left,
                kind: FieldKind::Text,
            }
        ));
    }

    #[test]
    fn parse_format_template_doubled_at_is_literal_at() {
        // Any line containing `@` is a picture line; `@@` escapes to one `@` in the picture.
        // With zero fields, the value line must be empty.
        let t = parse_format_template(&["@@email".to_string(), "".to_string()]).expect("parse");
        let FormatRecord::Picture { segments, exprs } = &t.records[0] else {
            panic!("expected picture");
        };
        assert!(exprs.is_empty());
        assert!(matches!(
            segments.as_slice(),
            [PictureSegment::Literal(s)] if s == "@email"
        ));
    }

    #[test]
    fn parse_format_template_picture_requires_value_line() {
        let err = parse_format_template(&["@<<<<".to_string()]).expect_err("missing value");
        assert!(err.to_string().contains("value line"));
    }

    #[test]
    fn parse_format_template_field_count_mismatch() {
        let err = parse_format_template(&["@<<, @<<".to_string(), "1".to_string()])
            .expect_err("mismatch");
        assert!(err.to_string().contains("picture field"));
    }

    #[test]
    fn parse_format_template_two_fields_two_exprs() {
        let t = parse_format_template(&["@<< @>>".to_string(), "1, 2".to_string()]).expect("parse");
        assert_eq!(t.records.len(), 1);
        let FormatRecord::Picture { exprs, .. } = &t.records[0] else {
            panic!("expected picture");
        };
        assert_eq!(exprs.len(), 2);
    }

    #[test]
    fn parse_format_value_line_qq_comma_qq_is_two_exprs() {
        let v = parse_format_value_line("qq(x), qq(y)").expect("parse");
        assert_eq!(
            v.len(),
            2,
            "comma-separated qq() should be two value expressions"
        );
    }

    #[test]
    fn parse_format_value_line_rejects_extra_tokens_after_expr() {
        let err = parse_format_value_line("42 junk").expect_err("extra tokens");
        assert!(err.to_string().contains("Extra tokens"));
    }

    #[test]
    fn parse_picture_numeric_field() {
        let t = parse_format_template(&["@###".to_string(), "0".to_string()]).expect("parse");
        let FormatRecord::Picture { segments, .. } = &t.records[0] else {
            panic!("expected picture");
        };
        assert!(matches!(
            &segments[0],
            PictureSegment::Field {
                width: 4,
                align: FieldAlign::Numeric,
                kind: FieldKind::Numeric,
            }
        ));
    }

    #[test]
    fn parse_picture_right_center_multiline_and_bare_at() {
        let t = parse_format_template(&["@>> @|| @** @".to_string(), "1, 2, 3, 4".to_string()])
            .expect("parse");
        let FormatRecord::Picture { segments, .. } = &t.records[0] else {
            panic!("expected picture");
        };
        let fields: Vec<_> = segments
            .iter()
            .filter_map(|s| match s {
                PictureSegment::Field { width, align, kind } => Some((*width, *align, *kind)),
                _ => None,
            })
            .collect();
        assert_eq!(fields.len(), 4);
        assert!(matches!(fields[0], (3, FieldAlign::Right, FieldKind::Text)));
        assert!(matches!(
            fields[1],
            (3, FieldAlign::Center, FieldKind::Text)
        ));
        assert!(matches!(
            fields[2],
            (3, FieldAlign::Multiline, FieldKind::Multiline)
        ));
        assert!(matches!(fields[3], (1, FieldAlign::Left, FieldKind::Text)));
    }

    #[test]
    fn parse_picture_literal_between_fields() {
        let t = parse_format_template(&["a@<<b".to_string(), "qq(z)".to_string()]).expect("parse");
        let FormatRecord::Picture { segments, .. } = &t.records[0] else {
            panic!("expected picture");
        };
        assert!(matches!(&segments[0], PictureSegment::Literal(s) if s == "a"));
        assert!(matches!(
            &segments[1],
            PictureSegment::Field {
                width: 3,
                align: FieldAlign::Left,
                kind: FieldKind::Text,
            }
        ));
        assert!(matches!(&segments[2], PictureSegment::Literal(s) if s == "b"));
    }

    #[test]
    fn parse_format_template_literal_after_picture() {
        let t =
            parse_format_template(&["@<<".to_string(), "qq(x)".to_string(), "footer".to_string()])
                .expect("parse");
        assert_eq!(t.records.len(), 2);
        assert!(matches!(&t.records[1], FormatRecord::Literal(s) if s == "footer"));
    }

    #[test]
    fn pad_field_left_aligns_and_pads() {
        assert_eq!(pad_field("hi", 5, FieldAlign::Left), "hi   ");
    }

    #[test]
    fn pad_field_right_aligns() {
        assert_eq!(pad_field("hi", 5, FieldAlign::Right), "   hi");
    }

    #[test]
    fn pad_field_center_aligns() {
        assert_eq!(pad_field("hi", 5, FieldAlign::Center), " hi  ");
    }

    #[test]
    fn pad_field_numeric_right_aligns_integer() {
        assert_eq!(pad_field("42", 5, FieldAlign::Numeric), "   42");
    }

    #[test]
    fn pad_field_numeric_float() {
        assert_eq!(pad_field("3.5", 6, FieldAlign::Numeric), "   3.5");
    }

    #[test]
    fn pad_field_numeric_non_numeric_fallback_like_right() {
        assert_eq!(pad_field("n/a", 5, FieldAlign::Numeric), "  n/a");
    }

    #[test]
    fn pad_field_truncates_to_width() {
        assert_eq!(pad_field("abcdef", 3, FieldAlign::Left), "abc");
    }

    #[test]
    fn pad_field_multiline_uses_first_line() {
        assert_eq!(
            pad_field("first\nsecond", 6, FieldAlign::Multiline),
            "first "
        );
    }

    // ─── parse_picture_segments — directly exercise the picture parser ──
    //
    // The picture parser drives `write()` / `format` template
    // dispatch. Until now it was only smoke-tested through
    // `parse_format_template` round-trips (a 1-line picture per
    // test). These tests pin the parser's behaviour for every
    // segment shape so a regression to one align type or to the
    // literal-escape path can't sneak past CI by leaving
    // `parse_format_template` plumbing intact.

    fn fields_only(pic: &str) -> Vec<(usize, FieldAlign)> {
        parse_picture_segments(pic)
            .expect("parse picture")
            .into_iter()
            .filter_map(|s| match s {
                PictureSegment::Field { width, align, .. } => Some((width, align)),
                PictureSegment::Literal(_) => None,
            })
            .collect()
    }

    fn segments(pic: &str) -> Vec<PictureSegment> {
        parse_picture_segments(pic).expect("parse picture")
    }

    #[test]
    fn picture_empty_string_is_zero_segments() {
        assert!(segments("").is_empty());
    }

    #[test]
    fn picture_pure_literal_emits_single_literal_segment() {
        let segs = segments("just text");
        assert_eq!(segs.len(), 1);
        assert!(matches!(&segs[0], PictureSegment::Literal(s) if s == "just text"));
    }

    #[test]
    fn picture_bare_at_with_no_modifier_is_width_one_left_field() {
        // `@` alone (no `<`/`>`/`|`/`#`/`*`) → width 1 left-aligned text.
        let segs = segments("@");
        assert_eq!(segs.len(), 1);
        let PictureSegment::Field { width, align, kind } = &segs[0] else {
            panic!("expected Field, got {:?}", segs[0])
        };
        assert_eq!(*width, 1);
        assert_eq!(*align, FieldAlign::Left);
        assert_eq!(*kind, FieldKind::Text);
    }

    #[test]
    fn picture_left_align_lt_chain_counts_width_correctly() {
        // `@<<<<` = `@` + four `<` = width 5 left-aligned.
        assert_eq!(fields_only("@<<<<"), vec![(5, FieldAlign::Left)]);
    }

    #[test]
    fn picture_right_align_gt_chain() {
        // `@>>` = `@` + two `>` = width 3 right-aligned.
        assert_eq!(fields_only("@>>"), vec![(3, FieldAlign::Right)]);
    }

    #[test]
    fn picture_center_align_pipe_chain() {
        assert_eq!(fields_only("@|||"), vec![(4, FieldAlign::Center)]);
    }

    #[test]
    fn picture_numeric_align_hash_chain_carries_numeric_kind() {
        let segs = segments("@###");
        let PictureSegment::Field { width, align, kind } = &segs[0] else {
            panic!("expected Field")
        };
        assert_eq!(*width, 4);
        assert_eq!(*align, FieldAlign::Numeric);
        assert_eq!(*kind, FieldKind::Numeric, "numeric align → numeric kind");
    }

    #[test]
    fn picture_multiline_align_star_chain_carries_multiline_kind() {
        let segs = segments("@**");
        let PictureSegment::Field { width, align, kind } = &segs[0] else {
            panic!("expected Field")
        };
        assert_eq!(*width, 3);
        assert_eq!(*align, FieldAlign::Multiline);
        assert_eq!(*kind, FieldKind::Multiline);
    }

    #[test]
    fn picture_doubled_at_escapes_to_literal_at() {
        // `@@` → literal `@` (no field emitted), no value-line entry needed.
        let segs = segments("@@");
        assert_eq!(segs.len(), 1);
        assert!(matches!(&segs[0], PictureSegment::Literal(s) if s == "@"));
    }

    #[test]
    fn picture_literal_around_field_preserves_both() {
        // `[name: @<<<<]` → 3 segments: literal "[name: ", field, literal "]".
        let segs = segments("[name: @<<<<]");
        assert_eq!(segs.len(), 3);
        assert!(matches!(&segs[0], PictureSegment::Literal(s) if s == "[name: "));
        assert!(matches!(
            &segs[1],
            PictureSegment::Field {
                width: 5,
                align: FieldAlign::Left,
                ..
            }
        ));
        assert!(matches!(&segs[2], PictureSegment::Literal(s) if s == "]"));
    }

    #[test]
    fn picture_multiple_fields_collect_in_order() {
        // `@<< @>>> @###` → left(3), right(4), numeric(4) — separated by
        // single-space literals.
        let segs = segments("@<< @>>> @###");
        let fields: Vec<_> = segs
            .iter()
            .filter_map(|s| match s {
                PictureSegment::Field { width, align, .. } => Some((*width, *align)),
                _ => None,
            })
            .collect();
        assert_eq!(
            fields,
            vec![
                (3, FieldAlign::Left),
                (4, FieldAlign::Right),
                (4, FieldAlign::Numeric),
            ],
        );
    }

    #[test]
    fn picture_at_followed_by_non_modifier_treats_as_width_one() {
        // `@x` — `@` not followed by a known modifier byte falls into the
        // width=1 left-align default arm; the `x` becomes part of the
        // trailing literal.
        let segs = segments("@x");
        assert_eq!(segs.len(), 2);
        assert!(matches!(
            &segs[0],
            PictureSegment::Field {
                width: 1,
                align: FieldAlign::Left,
                ..
            }
        ));
        assert!(matches!(&segs[1], PictureSegment::Literal(s) if s == "x"));
    }
}