sif_parser/

emit.rs

// SIF Core v1 — Emitter.
//
// Writes SIF documents to any `Write` target.
//
// Reference: SIF-SPEC.md §25.1 (For Emitters).

use std::io::Write;

use crate::types::*;

/// A SIF document emitter.
pub struct Emitter<W: Write> {
    out: W,
}

impl<W: Write> Emitter<W> {
    pub fn new(out: W) -> Self {
        Self { out }
    }

    /// Write a complete document.
    pub fn emit_document(&mut self, doc: &Document) -> std::io::Result<()> {
        self.emit_header(&doc.header)?;
        for (i, section) in doc.sections.iter().enumerate() {
            if i > 0 {
                self.emit_section_break()?;
            }
            self.emit_section(section)?;
        }
        Ok(())
    }

    /// Write the header line.
    pub fn emit_header(&mut self, header: &Header) -> std::io::Result<()> {
        write!(self.out, "#!sif v{}", header.version)?;
        for (key, value) in &header.attributes {
            if value.contains(' ') || value.contains('"') {
                write!(self.out, " {}=\"{}\"", key, escape_quoted(value))?;
            } else {
                write!(self.out, " {}={}", key, value)?;
            }
        }
        writeln!(self.out)
    }

    /// Write a section break.
    pub fn emit_section_break(&mut self) -> std::io::Result<()> {
        writeln!(self.out, "---")
    }

    /// Write a section identifier.
    pub fn emit_section_id(&mut self, id: &str) -> std::io::Result<()> {
        writeln!(self.out, "§{}", id)
    }

    /// Write a complete section.
    pub fn emit_section(&mut self, section: &Section) -> std::io::Result<()> {
        if let Some(ref id) = section.id {
            self.emit_section_id(id)?;
        }
        for directive in &section.directives {
            self.emit_directive(directive)?;
        }
        if let Some(ref schema) = section.schema {
            self.emit_schema(schema)?;
        }
        for template in &section.templates {
            self.emit_template(template)?;
        }
        for block in &section.blocks {
            self.emit_block(block)?;
        }
        for record in &section.records {
            self.emit_record(record)?;
        }
        Ok(())
    }

    /// Write a `#schema` directive.
    pub fn emit_schema(&mut self, schema: &Schema) -> std::io::Result<()> {
        write!(self.out, "#schema")?;
        for field in &schema.fields {
            write!(self.out, " ")?;
            if field.deprecated {
                write!(self.out, "∅")?;
            }
            write!(self.out, "{}:{}", field.name, field.field_type)?;
            if let Some(ref sem) = field.semantic {
                write!(self.out, ":{}", sem)?;
            }
            if !field.modifiers.is_empty() {
                write!(self.out, "|")?;
                for (i, m) in field.modifiers.iter().enumerate() {
                    if i > 0 {
                        write!(self.out, ",")?;
                    }
                    write!(self.out, "{}", m.name)?;
                    if let Some(ref v) = m.value {
                        if v.contains(',') || v.contains('|') || v.contains(' ') || v.contains('=')
                        {
                            write!(self.out, "=\"{}\"", escape_quoted(v))?;
                        } else {
                            write!(self.out, "={}", v)?;
                        }
                    }
                }
            }
        }
        writeln!(self.out)
    }

    /// Write a data record.
    pub fn emit_record(&mut self, record: &Record) -> std::io::Result<()> {
        match record.cdc_op {
            CdcOp::Insert => {}
            CdcOp::Update => write!(self.out, "Δ")?,
            CdcOp::Delete => write!(self.out, "∅")?,
        }
        for (i, value) in record.values.iter().enumerate() {
            if i > 0 {
                write!(self.out, "\t")?;
            }
            emit_value(&mut self.out, value, i == 0)?;
        }
        writeln!(self.out)
    }

    /// Write a directive.
    pub fn emit_directive(&mut self, directive: &Directive) -> std::io::Result<()> {
        match directive {
            Directive::Context(text) => writeln!(self.out, "#context {}", text),
            Directive::Source(text) => writeln!(self.out, "#source {}", text),
            Directive::License(text) => writeln!(self.out, "#license {}", text),
            Directive::Sort { field, direction } => {
                let dir = match direction {
                    SortDirection::Asc => "asc",
                    SortDirection::Desc => "desc",
                };
                writeln!(self.out, "#sort {} {}", field, dir)
            }
            Directive::Filter(text) => writeln!(self.out, "#filter {}", text),
            Directive::Limit(n) => writeln!(self.out, "#limit {}", n),
            Directive::Truncated(attrs) => {
                write!(self.out, "#truncated")?;
                for (k, v) in attrs {
                    write!(self.out, " {}={}", k, v)?;
                }
                writeln!(self.out)
            }
            Directive::Relation { from, to } => {
                write!(self.out, "#relation ")?;
                emit_field_ref(&mut self.out, from)?;
                write!(self.out, " -> ")?;
                emit_field_ref(&mut self.out, to)?;
                writeln!(self.out)
            }
            Directive::Recall => writeln!(self.out, "#recall schema"),
            Directive::Error(text) => writeln!(self.out, "#error {}", text),
            Directive::Unknown { name, content } => {
                if content.is_empty() {
                    writeln!(self.out, "#{}", name)
                } else {
                    writeln!(self.out, "#{} {}", name, content)
                }
            }
        }
    }

    /// Write a block.
    pub fn emit_block(&mut self, block: &Block) -> std::io::Result<()> {
        write!(self.out, "#block {}", block.block_type.as_str())?;
        for (k, v) in &block.attributes {
            if v.contains(' ') {
                write!(self.out, " {}=\"{}\"", k, escape_quoted(v))?;
            } else {
                write!(self.out, " {}={}", k, v)?;
            }
        }
        writeln!(self.out)?;
        write!(self.out, "{}", block.content)?;
        if !block.content.ends_with('\n') {
            writeln!(self.out)?;
        }
        writeln!(self.out, "#/block")
    }

    /// Write a template.
    pub fn emit_template(&mut self, template: &Template) -> std::io::Result<()> {
        writeln!(self.out, "#template {}", template.name)?;
        write!(self.out, "{}", template.body)?;
        if !template.body.ends_with('\n') {
            writeln!(self.out)?;
        }
        writeln!(self.out, "#/template")
    }

    /// Write a `#recall schema` directive.
    pub fn emit_recall(&mut self) -> std::io::Result<()> {
        writeln!(self.out, "#recall schema")
    }

    /// Get a mutable reference to the underlying writer.
    pub fn writer_mut(&mut self) -> &mut W {
        &mut self.out
    }

    /// Consume the emitter and return the underlying writer.
    pub fn into_inner(self) -> W {
        self.out
    }
}

fn emit_field_ref<W: Write>(out: &mut W, r: &FieldRef) -> std::io::Result<()> {
    if let Some(ref section) = r.section {
        write!(out, "§{}.{}", section, r.field)
    } else {
        write!(out, "{}", r.field)
    }
}

/// Emit a single value, quoting strings when necessary per §11.
fn emit_value<W: Write>(out: &mut W, value: &Value, is_first_field: bool) -> std::io::Result<()> {
    match value {
        Value::Null => write!(out, "_"),
        Value::Bool(true) => write!(out, "T"),
        Value::Bool(false) => write!(out, "F"),
        Value::Int(n) => write!(out, "{}", n),
        Value::Uint(n) => write!(out, "{}", n),
        Value::Float(n) => {
            let s = n.to_string();
            if s.contains('.') {
                write!(out, "{}", s)
            } else {
                write!(out, "{}.0", s)
            }
        }
        Value::Str(s) => emit_string(out, s, is_first_field),
        Value::Date(s) | Value::DateTime(s) | Value::Duration(s) => write!(out, "{}", s),
        Value::Bytes(b) => write!(out, "{}", crate::types::base64_encode(b)),
        Value::Enum(s) => write!(out, "{}", s),
        Value::Array(arr) => {
            write!(out, "[")?;
            for (i, v) in arr.iter().enumerate() {
                if i > 0 {
                    write!(out, ",")?;
                }
                emit_value(out, v, false)?;
            }
            write!(out, "]")
        }
        Value::Map(entries) => {
            write!(out, "{{")?;
            for (i, (k, v)) in entries.iter().enumerate() {
                if i > 0 {
                    write!(out, ",")?;
                }
                write!(out, "{}:", k)?;
                emit_value(out, v, false)?;
            }
            write!(out, "}}")
        }
    }
}

/// Emit a string, quoting when required per §11.
fn emit_string<W: Write>(out: &mut W, s: &str, is_first_field: bool) -> std::io::Result<()> {
    if needs_quoting(s, is_first_field) {
        write!(out, "\"{}\"", escape_quoted(s))
    } else {
        write!(out, "{}", s)
    }
}

/// Check if a string value needs quoting per §11.
fn needs_quoting(s: &str, is_first_field: bool) -> bool {
    if s.is_empty() {
        return true;
    }
    if s.starts_with('"') {
        return true;
    }
    if s.starts_with(' ') || s.ends_with(' ') {
        return true;
    }
    if is_first_field && s.starts_with('#') {
        return true;
    }
    if is_first_field && s == "---" {
        return true;
    }
    for c in s.chars() {
        if c == '\t' || c == '\n' || c == ',' || c == '[' || c == ']' || c == '{' || c == '}' {
            return true;
        }
    }
    false
}

/// Escape a string for quoting (§11.1).
fn escape_quoted(s: &str) -> String {
    let mut out = String::with_capacity(s.len());
    for c in s.chars() {
        match c {
            '\n' => out.push_str("\\n"),
            '\t' => out.push_str("\\t"),
            '\\' => out.push_str("\\\\"),
            '"' => out.push_str("\\\""),
            _ => out.push(c),
        }
    }
    out
}

/// Convenience: emit a document to a String.
pub fn emit_to_string(doc: &Document) -> String {
    let mut buf = Vec::new();
    let mut emitter = Emitter::new(&mut buf);
    emitter.emit_document(doc).expect("write to Vec never fails");
    String::from_utf8(buf).expect("SIF output is always UTF-8")
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::parse::parse;
    use std::collections::HashMap;

    #[test]
    fn test_roundtrip() {
        let input = "\
#!sif v1
#context Test data
#schema id:uint:id name:str active:bool tags:str[]
1\talice\tT\t[admin,user]
2\tbob\tF\t[]
";
        let doc = parse(input).unwrap();
        let output = emit_to_string(&doc);
        let reparsed = parse(&output).unwrap();

        assert_eq!(doc.sections[0].records, reparsed.sections[0].records);
    }

    #[test]
    fn test_string_quoting() {
        assert!(!needs_quoting("hello", false));
        assert!(needs_quoting("", false));
        assert!(needs_quoting("has\ttab", false));
        assert!(needs_quoting("has\nnewline", false));
        assert!(needs_quoting("[bracket", false));
        assert!(needs_quoting("{brace}", false));
        assert!(needs_quoting("has,comma", false));
        assert!(needs_quoting(" leading space", false));
        assert!(!needs_quoting("#hash", false));
        assert!(needs_quoting("#hash", true));
        assert!(needs_quoting("---", true));
    }

    #[test]
    fn test_emit_blocks() {
        let doc = Document {
            header: Header {
                version: 1,
                attributes: HashMap::new(),
            },
            sections: vec![Section {
                id: None,
                directives: vec![],
                schema: None,
                records: vec![],
                blocks: vec![Block {
                    block_type: BlockType::Code,
                    attributes: vec![("language".to_string(), "rust".to_string())],
                    content: "fn main() {}".to_string(),
                }],
                templates: vec![],
            }],
        };
        let output = emit_to_string(&doc);
        assert!(output.contains("#block code language=rust"));
        assert!(output.contains("fn main() {}"));
        assert!(output.contains("#/block"));
    }

    #[test]
    fn test_emit_cdc() {
        let doc = Document {
            header: Header {
                version: 1,
                attributes: HashMap::new(),
            },
            sections: vec![Section {
                id: None,
                directives: vec![],
                schema: Some(Schema {
                    fields: vec![
                        FieldDef {
                            name: "id".to_string(),
                            field_type: Type::Uint,
                            semantic: Some("id".to_string()),
                            deprecated: false,
                            modifiers: vec![],
                        },
                        FieldDef {
                            name: "name".to_string(),
                            field_type: Type::Str,
                            semantic: None,
                            deprecated: false,
                            modifiers: vec![],
                        },
                    ],
                }),
                records: vec![
                    Record {
                        values: vec![Value::Uint(1), Value::Str("alice".to_string())],
                        cdc_op: CdcOp::Insert,
                    },
                    Record {
                        values: vec![Value::Uint(1), Value::Str("alice2".to_string())],
                        cdc_op: CdcOp::Update,
                    },
                    Record {
                        values: vec![Value::Uint(1), Value::Str("alice2".to_string())],
                        cdc_op: CdcOp::Delete,
                    },
                ],
                blocks: vec![],
                templates: vec![],
            }],
        };
        let output = emit_to_string(&doc);
        assert!(output.contains("1\talice\n"));
        assert!(output.contains("Δ1\talice2\n"));
        assert!(output.contains("∅1\talice2\n"));
    }
}