document.rs

//! 文書。docx と doc を開く
//!
//! ```no_run
//! use folio::document::Document;
//! use std::path::Path;
//!
//! let mut document = Document::open(Path::new("file.docx")).unwrap();
//! println!("{}", document.text().unwrap());
//! ```
//!
//! 段落や表として受け取るときは、本文を順に読む。
//!
//! ```no_run
//! use folio::document::{Block, Document};
//! use std::path::Path;
//!
//! let mut document = Document::open(Path::new("file.docx")).unwrap();
//! let mut body = document.read().unwrap();
//!
//! while let Some(block) = body.read().unwrap() {
//!     match block {
//!         Block::Paragraph(one) => println!("{}", one.text()),
//!         Block::Table(one) => println!("表 {} 行", one.row.len()),
//!     }
//! }
//! ```

use crate::error::Error;
use crate::package::Package;
use crate::paragraph::{self, Paragraph};
use crate::table::{self, Table};
use crate::xml::{Event, Reader as XmlReader};
use std::path::Path;


/// 本文に並ぶもの
#[derive(Debug, Clone, PartialEq)]
pub enum Block {
    Paragraph(Paragraph),
    Table(Table),
}


impl Block {
    /// 中の文字。表は、セルをタブで、行を改行でつなぐ
    pub fn text(&self) -> String {
        match self {
            Block::Paragraph(one) => one.text(),

            Block::Table(one) => {
                let mut result = String::new();

                for row in &one.row {
                    if !result.is_empty() {
                        result.push('\n');
                    }

                    for (index, cell) in row.cell.iter().enumerate() {
                        if index > 0 {
                            result.push('\t');
                        }

                        result.push_str(&cell.text());
                    }
                }

                result
            }
        }
    }
}


/// どちらの形式を開いたか
enum Origin {
    /// docx
    Package(Package),
    /// doc。段落ごとの文字だけを持つ
    Record(Vec<String>),
}


/// 読むために開いた文書
pub struct Document {
    source: Origin,
    main: String,
}


impl Document {
    /// docx か doc を開く
    ///
    /// 先頭のバイトを見て、どちらの形式かを決める。読む側は形式を気にしなくてよい。
    pub fn open(path: &Path) -> Result<Document, Error> {
        if crate::cfb::is_compound(path) {
            return open_record(path);
        }

        let mut package = Package::open(path)?;
        let main = package.main()?;

        if !package.has(&main) {
            return Err(Error::at("本文のパートがありません", &main));
        }

        Ok(Document {source: Origin::Package(package), main})
    }

    /// 本文のパートの名前
    pub fn main(&self) -> &str {
        &self.main
    }

    /// 包みそのもの。folio が読まないパートを自分で取り出すときに使う
    ///
    /// 旧形式には包みがないので None を返す。
    pub fn package(&mut self) -> Option<&mut Package> {
        match &mut self.source {
            Origin::Package(one) => Some(one),
            Origin::Record(_) => None,
        }
    }

    /// 旧形式かどうか
    pub fn is_record(&self) -> bool {
        matches!(self.source, Origin::Record(_))
    }

    /// 本文を順に読む
    pub fn read(&mut self) -> Result<Reader, Error> {
        match &mut self.source {
            Origin::Package(package) => Ok(Reader {
                source: Source::Body(package.reader(&self.main)?),
                inside: false,
                ended: false,
            }),

            Origin::Record(line) => Ok(Reader {
                source: Source::Line(line.clone(), 0),
                inside: true,
                ended: false,
            }),
        }
    }

    /// 本文の文字だけを、段落ごとに改行でつないで返す
    pub fn text(&mut self) -> Result<String, Error> {
        let mut body = self.read()?;
        let mut result = String::new();

        while let Some(block) = body.read()? {
            result.push_str(&block.text());
            result.push('\n');
        }

        Ok(result)
    }
}


/// 本文をどこから受け取るか
enum Source {
    /// docx の本文のパート
    Body(XmlReader),
    /// doc から取り出した段落
    Line(Vec<String>, usize),
}


/// 本文を段落と表に分けて順に返すもの
///
/// 段落は数千から数万で、シートの行のような数にはならない。
/// だから 1 つずつ持ち主ごと返す。読む側は借りたものを気にしなくてよい。
pub struct Reader {
    source: Source,
    /// `<w:body>` の中に入ったか
    inside: bool,
    ended: bool,
}


impl Reader {
    /// 次の段落か表。終わったら None
    pub fn read(&mut self) -> Result<Option<Block>, Error> {
        if self.ended {
            return Ok(None);
        }

        let source = match &mut self.source {
            Source::Body(one) => one,

            Source::Line(line, at) => {
                if *at >= line.len() {
                    self.ended = true;
                    return Ok(None);
                }

                let one = Paragraph::new(&line[*at]);
                *at += 1;
                return Ok(Some(Block::Paragraph(one)));
            }
        };

        while let Some(event) = source.next()? {
            if event == Event::Close {
                if source.name() == "body" {
                    self.ended = true;
                    return Ok(None);
                }

                continue;
            }

            if event == Event::Text {
                continue;
            }

            let empty = event == Event::Empty;

            match source.name() {
                "body" => {
                    self.inside = !empty;

                    if empty {
                        self.ended = true;
                        return Ok(None);
                    }
                }

                "p" if self.inside => {
                    if empty {
                        return Ok(Some(Block::Paragraph(Paragraph::default())));
                    }

                    return Ok(Some(Block::Paragraph(paragraph::read(source)?)));
                }

                "tbl" if self.inside && !empty => {
                    return Ok(Some(Block::Table(table::read(source)?)));
                }

                _ => {}
            }
        }

        self.ended = true;
        Ok(None)
    }
}


/// doc を開く
fn open_record(path: &Path) -> Result<Document, Error> {
    let mut file = crate::cfb::Compound::open(path)?;

    if !file.has("WordDocument") {
        return Err(Error::new("doc の WordDocument ストリームがありません"));
    }

    let main = file.read("WordDocument")?;
    let name = crate::doc::table_name(&main)?;

    if !file.has(name) {
        return Err(Error::new(format!("doc の {name} ストリームがありません")));
    }

    let table = file.read(name)?;
    let line = crate::doc::read(&main, &table)?;

    Ok(Document {
        source: Origin::Record(line),
        main: "WordDocument".to_string(),
    })
}