mod assemble;
mod classify;
mod dispatch;
mod document;
mod helpers;
mod types;
pub use dispatch::SUPPORTED_DOCUMENT_EXTENSIONS;
pub use document::{
BodyFragments, DocumentKind, NoteDocument, ParseContext, TagsIter, TagsStrIter, TodoState,
};
use crate::error::NbError;
use crate::tokenizer::tokenize;
use assemble::{assemble_bookmark, assemble_note, assemble_todo, translate_parse_failure};
use classify::{classify_bookmark, classify_note, classify_todo};
use dispatch::{FormatDispatch, format_dispatch};
use document::Partition;
pub fn parse(bytes: &[u8], context: ParseContext) -> Result<NoteDocument, NbError> {
let kind = match context {
ParseContext::FromPath(path) => match format_dispatch(&path) {
FormatDispatch::SupportedKind(kind) => kind,
FormatDispatch::Rejected(extension) => {
return Err(NbError::UnsupportedDocumentFormat {
extension,
supported: SUPPORTED_DOCUMENT_EXTENSIONS
.iter()
.map(|s| s.to_string())
.collect(),
});
}
FormatDispatch::MarkdownNote => DocumentKind::Note,
},
ParseContext::Explicit(kind) => kind,
};
let mut source = Vec::with_capacity(bytes.len());
source.extend_from_slice(bytes);
let (preamble, lines) = tokenize(&source);
let partition = match kind {
DocumentKind::Note => {
let tokens = classify_note(&lines);
match assemble_note(&source, &preamble, &lines, &tokens) {
Ok(p) => Partition::Note(p),
Err(failure) => return Err(translate_parse_failure(failure)),
}
}
DocumentKind::Todo => {
let tokens = classify_todo(&lines);
match assemble_todo(&source, &preamble, &lines, &tokens) {
Ok(p) => Partition::Todo(p),
Err(failure) => return Err(translate_parse_failure(failure)),
}
}
DocumentKind::Bookmark => {
let tokens = classify_bookmark(&lines);
match assemble_bookmark(&source, &preamble, &lines, &tokens) {
Ok(p) => Partition::Bookmark(p),
Err(failure) => return Err(translate_parse_failure(failure)),
}
}
};
let doc = NoteDocument { source, partition };
debug_assert!(doc.verify_partition().is_ok());
Ok(doc)
}