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)
}