sif_parser/

reader.rs

// SIF Core v1 — Streaming event-based reader.
//
// Reads a SIF document line-by-line and emits `Event` values.
// Maintains internal state for the active schema so records are
// parsed against the correct type definitions.
//
// Reference: SIF-SPEC.md §5 (Document Structure), §25.2 (For Parsers).

use std::io::BufRead;

use crate::error::{err, ErrorKind, Result};
use crate::parse::parse_schema_str;
use crate::types::*;

/// A streaming, event-based SIF reader.
///
/// Reads lines from any `BufRead` source and yields `Event` values
/// one at a time via `next_event()`.
///
/// ```ignore
/// use sif_parser::{Reader, Event};
/// let mut reader = Reader::from_str(sif_text);
/// while let Some(event) = reader.next_event()? {
///     match event {
///         Event::Record(r) => { /* process record */ }
///         _ => {}
///     }
/// }
/// ```
pub struct Reader<R: BufRead> {
    source: R,
    line_buf: String,
    line_num: usize,
    schema: Option<Schema>,
    state: ReaderState,
    header_read: bool,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum ReaderState {
    Normal,
    InBlock,
    InTemplate,
}

impl<R: BufRead> Reader<R> {
    /// Create a new reader from a buffered source.
    pub fn new(source: R) -> Self {
        Self {
            source,
            line_buf: String::new(),
            line_num: 0,
            schema: None,
            state: ReaderState::Normal,
            header_read: false,
        }
    }

    /// Returns the current active schema, if any.
    pub fn schema(&self) -> Option<&Schema> {
        self.schema.as_ref()
    }

    /// Returns the current line number (1-based).
    pub fn line_num(&self) -> usize {
        self.line_num
    }

    /// Read the next event from the stream.
    ///
    /// Returns `Ok(None)` at end of input.
    pub fn next_event(&mut self) -> Result<Option<Event>> {
        loop {
            self.line_buf.clear();
            let bytes_read = self
                .source
                .read_line(&mut self.line_buf)
                .map_err(|e| err(ErrorKind::UnexpectedEof, self.line_num, e.to_string()))?;

            if bytes_read == 0 {
                return Ok(None);
            }

            self.line_num += 1;
            let line = self.line_buf.trim_end_matches('\n').trim_end_matches('\r');

            // Handle BOM on first line
            let line = if self.line_num == 1 {
                line.strip_prefix('\u{FEFF}').unwrap_or(line)
            } else {
                line
            };

            // Inside a block — emit lines until #/block
            if self.state == ReaderState::InBlock {
                if line.trim_end() == "#/block" {
                    self.state = ReaderState::Normal;
                    return Ok(Some(Event::BlockEnd));
                }
                return Ok(Some(Event::BlockLine(line.to_string())));
            }

            // Inside a template — emit lines until #/template
            if self.state == ReaderState::InTemplate {
                if line.trim_end() == "#/template" {
                    self.state = ReaderState::Normal;
                    return Ok(Some(Event::TemplateEnd));
                }
                return Ok(Some(Event::TemplateLine(line.to_string())));
            }

            // Skip empty lines
            if line.trim().is_empty() {
                continue;
            }

            // Header
            if !self.header_read {
                self.header_read = true;
                let header = crate::parse::parse_header_public(line, self.line_num)?;
                return Ok(Some(Event::Header(header)));
            }

            // Skip #! after header (§5.3)
            if line.starts_with("#!") {
                continue;
            }

            // Section break
            if line.trim_end() == "---" {
                self.schema = None;
                return Ok(Some(Event::SectionBreak));
            }

            // Section identifier
            if line.starts_with('§') {
                let id = &line['§'.len_utf8()..];
                return Ok(Some(Event::SectionId(id.trim_end().to_string())));
            }

            // Block start
            if line.starts_with("#block ") {
                let rest = &line[7..];
                let tokens: Vec<&str> = rest.split_whitespace().collect();
                if tokens.is_empty() {
                    return Err(err(ErrorKind::InvalidBlock, self.line_num, "missing block type"));
                }
                let block_type = match tokens[0] {
                    "code" => BlockType::Code,
                    "text" => BlockType::Text,
                    "diff" => BlockType::Diff,
                    "raw" => BlockType::Raw,
                    "template" => BlockType::Template,
                    other => {
                        return Err(err(
                            ErrorKind::InvalidBlock,
                            self.line_num,
                            format!("unknown block type: {}", other),
                        ));
                    }
                };
                let mut attrs = Vec::new();
                for &token in &tokens[1..] {
                    if let Some(eq) = token.find('=') {
                        attrs.push((token[..eq].to_string(), token[eq + 1..].to_string()));
                    }
                }
                self.state = ReaderState::InBlock;
                return Ok(Some(Event::BlockStart {
                    block_type,
                    attributes: attrs,
                }));
            }

            // Template start
            if line.starts_with("#template ") {
                let name = line[10..].trim().to_string();
                self.state = ReaderState::InTemplate;
                return Ok(Some(Event::TemplateStart(name)));
            }

            // Schema
            if line.starts_with("#schema ") {
                let schema_body = &line[8..];
                let schema = parse_schema_str(schema_body, self.line_num)?;
                self.schema = Some(schema.clone());
                return Ok(Some(Event::Schema(schema)));
            }

            // Recall — emit as directive but don't change state
            if line.trim_end() == "#recall schema" {
                return Ok(Some(Event::Directive(Directive::Recall)));
            }

            // Other directives
            if line.starts_with('#') {
                if let Some(directive) = crate::parse::parse_directive_public(line, self.line_num)?
                {
                    return Ok(Some(Event::Directive(directive)));
                }
                continue;
            }

            // Record — parse against active schema
            if let Some(ref schema) = self.schema {
                let record =
                    crate::parse::parse_record_public(line, schema, self.line_num)?;
                return Ok(Some(Event::Record(record)));
            } else {
                return Err(err(
                    ErrorKind::RecordWithoutSchema,
                    self.line_num,
                    "record found before any #schema in this section",
                ));
            }
        }
    }

    /// Collect all events into a Vec (convenience for testing/small docs).
    pub fn collect_events(&mut self) -> Result<Vec<Event>> {
        let mut events = Vec::new();
        while let Some(event) = self.next_event()? {
            events.push(event);
        }
        Ok(events)
    }
}

/// Create a reader from a string.
impl Reader<std::io::BufReader<std::io::Cursor<String>>> {
    pub fn from_str(input: &str) -> Self {
        let cursor = std::io::Cursor::new(input.to_string());
        Self::new(std::io::BufReader::new(cursor))
    }
}

/// Create a reader from stdin.
pub fn reader_stdin() -> Reader<std::io::BufReader<std::io::Stdin>> {
    Reader::new(std::io::BufReader::new(std::io::stdin()))
}

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

    #[test]
    fn test_streaming_reader() {
        let input = "\
#!sif v1
#context Test
#schema id:uint name:str
1\talice
2\tbob
";
        let mut reader = Reader::from_str(input);
        let events = reader.collect_events().unwrap();

        assert!(matches!(&events[0], Event::Header(_)));
        assert!(matches!(&events[1], Event::Directive(Directive::Context(_))));
        assert!(matches!(&events[2], Event::Schema(_)));
        assert!(matches!(&events[3], Event::Record(_)));
        assert!(matches!(&events[4], Event::Record(_)));
        assert_eq!(events.len(), 5);
    }

    #[test]
    fn test_streaming_sections() {
        let input = "\
#!sif v1
§first
#schema a:str
hello
---
§second
#schema b:uint
42
";
        let mut reader = Reader::from_str(input);
        let events = reader.collect_events().unwrap();

        let section_ids: Vec<_> = events
            .iter()
            .filter_map(|e| match e {
                Event::SectionId(id) => Some(id.as_str()),
                _ => None,
            })
            .collect();
        assert_eq!(section_ids, vec!["first", "second"]);

        let breaks = events
            .iter()
            .filter(|e| matches!(e, Event::SectionBreak))
            .count();
        assert_eq!(breaks, 1);
    }

    #[test]
    fn test_streaming_blocks() {
        let input = "\
#!sif v1
#block code language=rust
fn main() {}
#/block
";
        let mut reader = Reader::from_str(input);
        let events = reader.collect_events().unwrap();

        assert!(matches!(
            &events[1],
            Event::BlockStart {
                block_type: BlockType::Code,
                ..
            }
        ));
        assert!(matches!(&events[2], Event::BlockLine(_)));
        assert!(matches!(&events[3], Event::BlockEnd));
    }
}