book.rs

//! ワークブック。xlsx と xls を開く
//!
//! ```no_run
//! use folio::book::Book;
//! use std::path::Path;
//!
//! let mut book = Book::open(Path::new("data.xlsx")).unwrap();
//!
//! for one in book.sheet() {
//!     println!("{}", one.name);
//! }
//! ```

use crate::cfb;
use crate::error::Error;
use crate::package::Package;
use crate::shared::Shared;
use crate::sheet;
use crate::style::Style;
use crate::xls;
use crate::xml::{Event, Reader};
use std::path::Path;
use std::sync::Arc;


/// ワークブックに載っているシート
#[derive(Debug, Clone)]
pub struct Sheet {
    /// 見出しに出る名前
    pub name: String,
    /// パートの名前
    pub part: String,
    /// 隠していないか
    pub visible: bool,
}


/// どちらの形式を開いたか
enum Origin {
    /// xlsx
    Package(Package),
    /// xls
    Record(xls::Book),
}


/// 読むために開いたワークブック
pub struct Book {
    source: Origin,
    sheet: Vec<Sheet>,
    shared: Arc<Shared>,
    style: Arc<Style>,
    epoch1904: bool,
}


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

        let mut package = Package::open(path)?;
        let main = package.main()?;
        let (listed, epoch1904) = read_workbook(&mut package, &main)?;
        let link = package.relationship(&main)?;
        let mut sheet = Vec::with_capacity(listed.len());

        for (name, id, visible) in listed {
            let Some(one) = link.iter().find(|one| one.id == id) else {
                return Err(Error::at(format!("シート {name} の指し先がありません"), &main));
            };

            sheet.push(Sheet {name, part: one.target.clone(), visible});
        }

        // 共有文字列と書式の在り処も、いま読んだ関係から引く。関係のパートを読み直さない
        let find = |kind: &str| link.iter().find(|one| one.is(kind) && !one.external).map(|one| one.target.clone());

        let shared = match find("sharedStrings") {
            Some(part) if package.has(&part) => {
                let source = package.stream(&part)?;
                Shared::read(source).map_err(|error| error.within(&part))?
            }
            _ => Shared::new(),
        };

        let style = match find("styles") {
            Some(part) if package.has(&part) => {
                let mut reader = package.reader(&part)?;
                Style::read(&mut reader).map_err(|error| error.within(&part))?
            }
            _ => Style::new(),
        };

        Ok(Book {
            source: Origin::Package(package),
            sheet,
            shared: Arc::new(shared),
            style: Arc::new(style),
            epoch1904,
        })
    }

    /// 載っているシート
    pub fn sheet(&self) -> &[Sheet] {
        &self.sheet
    }

    /// 書式の対応
    pub fn style(&self) -> &Style {
        &self.style
    }

    /// 共有文字列
    pub fn shared(&self) -> &Shared {
        &self.shared
    }

    /// 1904 年方式かどうか
    pub fn epoch1904(&self) -> bool {
        self.epoch1904
    }

    /// 包みそのもの。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, name: &str) -> Result<sheet::Reader, Error> {
        let Some(index) = self.sheet.iter().position(|one| one.name == name) else {
            return Err(Error::new(format!("シート {name} がありません")));
        };

        let shared = self.shared.clone();
        let style = self.style.clone();
        let epoch1904 = self.epoch1904;

        match &mut self.source {
            Origin::Package(package) => {
                let part = self.sheet[index].part.clone();
                let source = package.stream(&part)?;
                Ok(sheet::Reader::new(source, shared, style, epoch1904))
            }

            Origin::Record(book) => {
                let source = book.cursor(index)?;
                Ok(sheet::Reader::over(source, shared, style, epoch1904))
            }
        }
    }
}


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

    let name = if file.has("Workbook") {
        "Workbook"
    } else if file.has("Book") {
        "Book"
    } else {
        return Err(Error::new("xls の Workbook ストリームがありません"));
    };

    let data = file.read(name)?;
    let mut book = xls::Book::open(data)?;

    let sheet = book
        .sheet
        .iter()
        .map(|one| Sheet {
            name: one.name.clone(),
            part: String::new(),
            visible: one.visible,
        })
        .collect();

    let shared = std::mem::take(&mut book.shared);
    let style = std::mem::take(&mut book.style);
    let epoch1904 = book.epoch1904;

    Ok(Book {
        source: Origin::Record(book),
        sheet,
        shared: Arc::new(shared),
        style: Arc::new(style),
        epoch1904,
    })
}


/// workbook.xml から、シートの並びと日付の方式を読む
fn read_workbook(package: &mut Package, main: &str) -> Result<(Vec<(String, String, bool)>, bool), Error> {
    let data = package.read(main)?;
    let mut reader = Reader::over(data);
    let mut sheet = Vec::new();
    let mut epoch1904 = false;

    while let Some(event) = reader.next().map_err(|error| error.within(main))? {
        if event != Event::Open && event != Event::Empty {
            continue;
        }

        match reader.name() {
            "workbookPr" => {
                let value = reader.attribute("date1904").unwrap_or("0");
                epoch1904 = value == "1" || value == "true";
            }

            "sheet" => {
                let name = reader.attribute("name").unwrap_or("").to_string();
                let id = reader.attribute("id").unwrap_or("").to_string();
                let visible = reader.attribute("state").unwrap_or("visible") == "visible";
                sheet.push((name, id, visible));
            }

            _ => {}
        }
    }

    Ok((sheet, epoch1904))
}