use std::collections::BTreeMap;
use std::fs;
use std::path::{Path, PathBuf};
use crate::parser::{parse_entries, Entry};
use crate::{CiteError, Result};
const BIB_EXTENSION: &str = "bib";
#[derive(Debug, Clone, Default)]
pub struct Bibliography {
entries: BTreeMap<String, Entry>,
}
impl Bibliography {
pub fn load_dir(dir: impl AsRef<Path>) -> Result<Self> {
let dir = dir.as_ref();
let paths = bib_paths_sorted(dir)?;
let mut entries = BTreeMap::new();
let mut source_of: BTreeMap<String, PathBuf> = BTreeMap::new();
for path in paths {
let source = fs::read_to_string(&path).map_err(|source| CiteError::Io {
path: path.clone(),
source,
})?;
let parsed = parse_entries(&source).map_err(|error| attribute(error, &path))?;
for (key, entry) in parsed {
if let Some(first_file) = source_of.get(&key) {
return Err(CiteError::DuplicateKey {
key,
first_file: first_file.clone(),
second_file: path,
});
}
source_of.insert(key.clone(), path.clone());
entries.insert(key, entry);
}
}
Ok(Self { entries })
}
pub fn from_entries(entries: impl IntoIterator<Item = (String, Entry)>) -> Self {
Self {
entries: entries.into_iter().collect(),
}
}
pub fn get(&self, key: &str) -> Option<&Entry> {
self.entries.get(key)
}
pub fn len(&self) -> usize {
self.entries.len()
}
pub fn is_empty(&self) -> bool {
self.entries.is_empty()
}
}
fn bib_paths_sorted(dir: &Path) -> Result<Vec<PathBuf>> {
let read_dir = fs::read_dir(dir).map_err(|source| CiteError::Io {
path: dir.to_path_buf(),
source,
})?;
let mut paths = Vec::new();
for dir_entry in read_dir {
let dir_entry = dir_entry.map_err(|source| CiteError::Io {
path: dir.to_path_buf(),
source,
})?;
let path = dir_entry.path();
if path.is_file() && path.extension().is_some_and(|ext| ext == BIB_EXTENSION) {
paths.push(path);
}
}
paths.sort();
Ok(paths)
}
fn attribute(error: CiteError, path: &Path) -> CiteError {
match error {
CiteError::Parse { file: None, message } => CiteError::Parse {
file: Some(path.to_path_buf()),
message,
},
other => other,
}
}
#[cfg(test)]
#[path = "../tests/unit/bibliography.rs"]
mod tests;