xml.rs

//! XML の読み書き
//!
//! OOXML のパートはどれも XML である。ここはそれを読む側と、書くときの逃がし方を持つ。
//!
//! # 事象を 1 つずつ返す
//!
//! 木を組み立てて返すことはしない。数 GB のシートは木にすると入らないためである。
//! [`Reader::next`] はタグの開き、閉じ、あいだの文字を 1 つずつ返し、
//! 名前と属性はそのつど [`Reader::name`] と [`Reader::attribute`] で引く。
//!
//! ```no_run
//! use folio::xml::{Event, Reader};
//!
//! let mut reader = Reader::over(b"<row r=\"1\"><c/></row>".to_vec());
//!
//! while let Some(event) = reader.next().unwrap() {
//!     if event == Event::Open && reader.name() == "row" {
//!         println!("{:?}", reader.attribute("r"));
//!     }
//! }
//! ```
//!
//! # 名前空間の前置き
//!
//! `<x:worksheet>` と `<worksheet>` は同じものを指す。前置きは書き手によって変わるので、
//! [`Reader::name`] は `:` から後ろだけを返す。
//!
//! 属性は前置きごと持つ。`id` と `r:id` の両方を持つ要素があり、落とすと見分けられないためである。
//! [`Reader::attribute`] は前置きなしで引くと、書かれたとおりの名前を先に、
//! なければ `:` から後ろが合うものを返す。`r:id` のように前置きごと渡すこともできる。

use crate::error::Error;
use crate::zip;


/// 読み込みの区切りを詰め直す境目
const COMPACT: usize = 64 * 1024;


/// 読み取った事象
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Event {
    /// `<name ...>`
    Open,
    /// `</name>`
    Close,
    /// `<name .../>`。開いてすぐ閉じるもの
    Empty,
    /// タグとタグのあいだの文字
    Text,
}


/// scratch の中の場所
type Span = (usize, usize);


/// 属性 1 つ
struct Field {
    name: Span,
    value: Span,
}


/// XML を順に読む
pub struct Reader {
    source: zip::Reader,
    /// まだ解釈していないバイト
    buffer: Vec<u8>,
    /// buffer のうち、いま見ている位置
    position: usize,
    /// source が尽きたか
    ended: bool,
    /// いまの事象の名前と値を入れておくところ
    scratch: String,
    name: Span,
    text: Span,
    attribute: Vec<Field>,
}


impl Reader {
    /// パートの中身を順に受け取りながら読む
    pub fn new(source: zip::Reader) -> Reader {
        Reader {
            source,
            buffer: Vec::with_capacity(COMPACT * 2),
            position: 0,
            ended: false,
            scratch: String::with_capacity(1024),
            name: (0, 0),
            text: (0, 0),
            attribute: Vec::with_capacity(8),
        }
    }

    /// そろっているバイト列を読む
    pub fn over(data: Vec<u8>) -> Reader {
        Reader::new(zip::Reader::plain(data))
    }

    /// いまの事象の名前。前置きは落としてある
    pub fn name(&self) -> &str {
        &self.scratch[self.name.0..self.name.1]
    }

    /// いまの文字。Text 以外では空
    pub fn text(&self) -> &str {
        &self.scratch[self.text.0..self.text.1]
    }

    /// 属性を名前で引く
    ///
    /// 書かれたとおりの名前が合えば、それを返す。合うものがなければ、`:` から後ろが合うものを返す。
    /// `<p:sldId id="256" r:id="rId2"/>` のように両方あるときは、`id` で 256 が、
    /// `r:id` で rId2 が返る。前置きが `r` でないファイルでも、`r:id` で引ける。
    pub fn attribute(&self, name: &str) -> Option<&str> {
        for one in &self.attribute {
            if self.written(one) == name {
                return Some(&self.scratch[one.value.0..one.value.1]);
            }
        }

        let prefixed = name.contains(':');
        let want = local(name);

        for one in &self.attribute {
            let full = self.written(one);

            if local(full) != want {
                continue;
            }

            // 前置きごと渡されたなら、前置きのない属性は合わない
            if prefixed && full.len() == want.len() {
                continue;
            }

            return Some(&self.scratch[one.value.0..one.value.1]);
        }

        None
    }

    /// 書かれたとおりの属性名
    fn written(&self, one: &Field) -> &str {
        &self.scratch[one.name.0..one.name.1]
    }

    /// 次の事象。終わったら None
    pub fn next(&mut self) -> Result<Option<Event>, Error> {
        if self.position >= COMPACT {
            self.buffer.copy_within(self.position.., 0);
            self.buffer.truncate(self.buffer.len() - self.position);
            self.position = 0;
        }

        loop {
            if !self.ensure(1)? {
                return Ok(None);
            }

            if self.buffer[self.position] != b'<' {
                let stop = self.scan(b'<')?;
                let from = self.position;
                self.position = stop;
                self.clear();
                self.text = self.put_text(from, stop)?;
                return Ok(Some(Event::Text));
            }

            if !self.ensure(2)? {
                return Err(Error::new("XML が < で終わっています"));
            }

            match self.buffer[self.position + 1] {
                b'?' => {
                    self.skip(b"?>")?;
                }

                b'!' => {
                    if self.starts(b"<!--")? {
                        self.skip(b"-->")?;
                        continue;
                    }

                    if self.starts(b"<![CDATA[")? {
                        self.position += 9;
                        let stop = self.locate(b"]]>")?;
                        let from = self.position;
                        self.position = stop + 3;
                        self.clear();
                        self.text = self.put_raw(from, stop)?;
                        return Ok(Some(Event::Text));
                    }

                    self.skip(b">")?;
                }

                b'/' => {
                    let stop = self.tag_end()?;
                    let from = self.position + 2;
                    self.clear();
                    self.name = self.put_name(from, stop)?;
                    self.position = stop + 1;
                    return Ok(Some(Event::Close));
                }

                _ => {
                    let stop = self.tag_end()?;
                    return Ok(Some(self.read_tag(stop)?));
                }
            }
        }
    }

    /// 開くタグを読む
    fn read_tag(&mut self, stop: usize) -> Result<Event, Error> {
        let mut cursor = self.position + 1;
        let mut end = stop;
        let mut empty = false;

        if end > cursor && self.buffer[end - 1] == b'/' {
            empty = true;
            end -= 1;
        }

        let start = cursor;

        while cursor < end && !space(self.buffer[cursor]) {
            cursor += 1;
        }

        self.clear();
        self.name = self.put_name(start, cursor)?;

        while cursor < end {
            while cursor < end && space(self.buffer[cursor]) {
                cursor += 1;
            }

            if cursor >= end {
                break;
            }

            let key = cursor;

            while cursor < end && self.buffer[cursor] != b'=' && !space(self.buffer[cursor]) {
                cursor += 1;
            }

            let key_end = cursor;

            while cursor < end && space(self.buffer[cursor]) {
                cursor += 1;
            }

            if cursor >= end || self.buffer[cursor] != b'=' {
                return Err(Error::new("XML の属性に = がありません"));
            }

            cursor += 1;

            while cursor < end && space(self.buffer[cursor]) {
                cursor += 1;
            }

            if cursor >= end {
                return Err(Error::new("XML の属性に値がありません"));
            }

            let quote = self.buffer[cursor];

            if quote != b'"' && quote != b'\'' {
                return Err(Error::new("XML の属性の値が引用符で囲まれていません"));
            }

            cursor += 1;
            let value = cursor;

            while cursor < end && self.buffer[cursor] != quote {
                cursor += 1;
            }

            let value_end = cursor;
            cursor = (cursor + 1).min(end);
            let name = self.put_raw(key, key_end)?;
            let body = self.put_text(value, value_end)?;
            self.attribute.push(Field {name, value: body});
        }

        self.position = stop + 1;

        if empty {
            Ok(Event::Empty)
        } else {
            Ok(Event::Open)
        }
    }

    /// 次の事象のために入れ物を空にする
    fn clear(&mut self) {
        self.scratch.clear();
        self.attribute.clear();
        self.name = (0, 0);
        self.text = (0, 0);
    }

    /// 名前を入れる。`:` から後ろだけを採る
    fn put_name(&mut self, from: usize, to: usize) -> Result<Span, Error> {
        let mut start = from;

        for index in from..to {
            if self.buffer[index] == b':' {
                start = index + 1;
            }
        }

        self.put_raw(start, to)
    }

    /// 実体参照を戻しながら入れる
    fn put_text(&mut self, from: usize, to: usize) -> Result<Span, Error> {
        let buffer = &self.buffer;
        let scratch = &mut self.scratch;
        let begin = scratch.len();
        let piece = &buffer[from..to];

        if !piece.contains(&b'&') {
            scratch.push_str(text_of(piece)?);
            return Ok((begin, scratch.len()));
        }

        let mut cursor = 0;

        while cursor < piece.len() {
            if piece[cursor] != b'&' {
                let start = cursor;

                while cursor < piece.len() && piece[cursor] != b'&' {
                    cursor += 1;
                }

                scratch.push_str(text_of(&piece[start..cursor])?);
                continue;
            }

            let Some(found) = piece[cursor..].iter().position(|byte| *byte == b';') else {
                return Err(Error::new("XML の実体参照が閉じていません"));
            };

            let body = &piece[cursor + 1..cursor + found];
            scratch.push(entity(body)?);
            cursor += found + 1;
        }

        Ok((begin, scratch.len()))
    }

    /// そのまま入れる
    fn put_raw(&mut self, from: usize, to: usize) -> Result<Span, Error> {
        let buffer = &self.buffer;
        let scratch = &mut self.scratch;
        let begin = scratch.len();
        scratch.push_str(text_of(&buffer[from..to])?);
        Ok((begin, scratch.len()))
    }

    /// position から先に n バイト用意する。source が尽きたら false
    fn ensure(&mut self, n: usize) -> Result<bool, Error> {
        while self.buffer.len() < self.position + n {
            if !self.fill()? {
                return Ok(false);
            }
        }

        Ok(true)
    }

    /// 続きを受け取る
    fn fill(&mut self) -> Result<bool, Error> {
        if self.ended {
            return Ok(false);
        }

        match self.source.next()? {
            Some(piece) => {
                self.buffer.extend_from_slice(&piece);
                Ok(true)
            }

            None => {
                self.ended = true;
                Ok(false)
            }
        }
    }

    /// byte が出るところを探す。なければ末尾
    fn scan(&mut self, byte: u8) -> Result<usize, Error> {
        let mut from = self.position;

        loop {
            if let Some(found) = self.buffer[from..].iter().position(|value| *value == byte) {
                return Ok(from + found);
            }

            from = self.buffer.len();

            if !self.fill()? {
                return Ok(self.buffer.len());
            }
        }
    }

    /// タグを閉じる > を探す。引用符の中の > は数えない
    fn tag_end(&mut self) -> Result<usize, Error> {
        let mut cursor = self.position;
        let mut quote = 0u8;

        loop {
            while cursor < self.buffer.len() {
                let byte = self.buffer[cursor];

                if quote != 0 {
                    if byte == quote {
                        quote = 0;
                    }
                } else if byte == b'"' || byte == b'\'' {
                    quote = byte;
                } else if byte == b'>' {
                    return Ok(cursor);
                }

                cursor += 1;
            }

            if !self.fill()? {
                return Err(Error::new("XML のタグが閉じていません"));
            }
        }
    }

    /// 並びが出るところを探す
    fn locate(&mut self, pattern: &[u8]) -> Result<usize, Error> {
        let mut from = self.position;

        loop {
            while from + pattern.len() <= self.buffer.len() {
                if &self.buffer[from..from + pattern.len()] == pattern {
                    return Ok(from);
                }

                from += 1;
            }

            if !self.fill()? {
                return Err(Error::new("XML が途中で終わっています"));
            }
        }
    }

    /// 並びの後ろまで飛ばす
    fn skip(&mut self, pattern: &[u8]) -> Result<(), Error> {
        let found = self.locate(pattern)?;
        self.position = found + pattern.len();
        Ok(())
    }

    /// いまの位置がこの並びで始まるか
    fn starts(&mut self, pattern: &[u8]) -> Result<bool, Error> {
        if !self.ensure(pattern.len())? {
            return Ok(false);
        }

        Ok(&self.buffer[self.position..self.position + pattern.len()] == pattern)
    }
}


/// `:` から後ろ
fn local(name: &str) -> &str {
    match name.rfind(':') {
        Some(cut) => &name[cut + 1..],
        None => name,
    }
}


/// 区切りに使う空白か
fn space(byte: u8) -> bool {
    byte == b' ' || byte == b'\t' || byte == b'\n' || byte == b'\r'
}


/// バイト列を文字列として見る
fn text_of(piece: &[u8]) -> Result<&str, Error> {
    match std::str::from_utf8(piece) {
        Ok(value) => Ok(value),
        Err(_) => Err(Error::new("XML が UTF-8 になっていません")),
    }
}


/// 実体参照の中身を 1 文字に戻す
fn entity(body: &[u8]) -> Result<char, Error> {
    match body {
        b"amp" => return Ok('&'),
        b"lt" => return Ok('<'),
        b"gt" => return Ok('>'),
        b"quot" => return Ok('"'),
        b"apos" => return Ok('\''),
        _ => {}
    }

    if body.first() != Some(&b'#') {
        return Err(Error::new("XML に知らない実体参照があります"));
    }

    let (digit, radix) = if body.get(1) == Some(&b'x') || body.get(1) == Some(&b'X') {
        (&body[2..], 16)
    } else {
        (&body[1..], 10)
    };

    let Ok(number) = u32::from_str_radix(text_of(digit)?, radix) else {
        return Err(Error::new("XML の文字参照が数になっていません"));
    };

    match char::from_u32(number) {
        Some(value) => Ok(value),
        None => Err(Error::new("XML の文字参照が文字になりません")),
    }
}


/// XML に置ける形に直して足す
///
/// XML 1.0 が受け付けない制御文字は落とす。タブ、改行、復帰は残す。
pub fn escape_into(text: &str, into: &mut String) {
    for value in text.chars() {
        match value {
            '&' => into.push_str("&amp;"),
            '<' => into.push_str("&lt;"),
            '>' => into.push_str("&gt;"),
            '"' => into.push_str("&quot;"),
            '\t' | '\n' | '\r' => into.push(value),
            _ => {
                if (value as u32) >= 0x20 {
                    into.push(value);
                }
            }
        }
    }
}


/// XML に置ける形に直す
pub fn escape(text: &str) -> String {
    let mut result = String::with_capacity(text.len());
    escape_into(text, &mut result);
    result
}