#[cfg(feature = "parser-config")]
pub mod config_file;
#[cfg(feature = "parser-html")]
pub mod html;
#[cfg(feature = "parser-markdown")]
pub mod markdown;
#[cfg(feature = "parser-plaintext")]
pub mod plaintext;
#[cfg(feature = "parser-code")]
pub mod treesitter;
use crate::document::{Document, SourceType};
use anyhow::Result;
use std::path::Path;
pub trait Parser: Send + Sync {
fn extensions(&self) -> &[&str];
fn source_type(&self) -> SourceType;
fn parse(&self, path: &Path, content: &str) -> Result<Document>;
}
pub struct ParserRegistry {
parsers: Vec<Box<dyn Parser>>,
}
impl ParserRegistry {
pub fn new() -> Self {
let parsers: Vec<Box<dyn Parser>> = Vec::new();
#[cfg(feature = "parser-markdown")]
let parsers = {
let mut parsers = parsers;
parsers.push(Box::new(markdown::MarkdownParser) as Box<dyn Parser>);
parsers
};
#[cfg(feature = "parser-html")]
let parsers = {
let mut parsers = parsers;
parsers.push(Box::new(html::HtmlParser) as Box<dyn Parser>);
parsers
};
#[cfg(feature = "parser-config")]
let parsers = {
let mut parsers = parsers;
parsers.push(Box::new(config_file::JsonParser) as Box<dyn Parser>);
parsers.push(Box::new(config_file::YamlParser) as Box<dyn Parser>);
parsers.push(Box::new(config_file::TomlParser) as Box<dyn Parser>);
parsers
};
#[cfg(feature = "parser-code")]
let parsers = {
let mut parsers = parsers;
parsers.push(Box::new(treesitter::TreeSitterParser) as Box<dyn Parser>);
parsers
};
#[cfg(feature = "parser-plaintext")]
let parsers = {
let mut parsers = parsers;
parsers.push(Box::new(plaintext::PlainTextParser) as Box<dyn Parser>);
parsers
};
Self { parsers }
}
pub fn empty() -> Self {
Self {
parsers: Vec::new(),
}
}
pub fn register<P>(&mut self, parser: P)
where
P: Parser + 'static,
{
self.parsers.push(Box::new(parser));
}
fn find_parser_by_ext(&self, ext: &str) -> Option<&dyn Parser> {
let ext_lower = ext.to_lowercase();
self.parsers
.iter()
.find(|p| p.extensions().iter().any(|e| *e == ext_lower))
.map(|p| p.as_ref())
}
fn find_parser_for_path(&self, path: &Path) -> Option<&dyn Parser> {
path.extension()
.and_then(|extension| extension.to_str())
.or_else(|| path.file_name().and_then(|name| name.to_str()))
.and_then(|discriminator| self.find_parser_by_ext(discriminator))
}
pub fn parse_file(&self, path: &Path) -> Result<Option<Document>> {
let parser = match self.find_parser_for_path(path) {
Some(p) => p,
None => return Ok(None),
};
let content = std::fs::read_to_string(path)?;
let abs_path = std::fs::canonicalize(path).unwrap_or_else(|_| path.to_path_buf());
let mut doc = parser.parse(path, &content)?;
doc.source_path = abs_path.to_string_lossy().to_string();
Ok(Some(doc))
}
pub fn parse_content(&self, path: &Path, content: &str) -> Result<Option<Document>> {
let parser = match self.find_parser_for_path(path) {
Some(p) => p,
None => return Ok(None),
};
let mut doc = parser.parse(path, content)?;
doc.source_path = path.to_string_lossy().to_string();
Ok(Some(doc))
}
pub fn supports(&self, path: &Path) -> bool {
self.find_parser_for_path(path).is_some()
}
}
impl Default for ParserRegistry {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[cfg(any(feature = "parser-config", feature = "parser-markdown"))]
use std::io::Write;
use tempfile::NamedTempFile;
#[test]
fn test_registry_supports() {
let reg = ParserRegistry::new();
#[cfg(feature = "parser-markdown")]
assert!(reg.supports(Path::new("readme.md")));
#[cfg(feature = "parser-html")]
assert!(reg.supports(Path::new("index.html")));
#[cfg(feature = "parser-code")]
assert!(reg.supports(Path::new("main.rs")));
#[cfg(feature = "parser-code")]
assert!(reg.supports(Path::new("Dockerfile")));
#[cfg(feature = "parser-code")]
assert!(reg.supports(Path::new("Makefile")));
#[cfg(feature = "parser-config")]
assert!(reg.supports(Path::new("config.json")));
#[cfg(feature = "parser-config")]
assert!(reg.supports(Path::new("data.yaml")));
#[cfg(feature = "parser-config")]
assert!(reg.supports(Path::new("data.yml")));
#[cfg(feature = "parser-config")]
assert!(reg.supports(Path::new("Cargo.toml")));
#[cfg(feature = "parser-plaintext")]
assert!(reg.supports(Path::new("notes.txt")));
assert!(!reg.supports(Path::new("image.png")));
assert!(!reg.supports(Path::new("noext")));
}
#[cfg(feature = "parser-markdown")]
#[test]
fn test_registry_parse_file_markdown() {
let mut tmp = NamedTempFile::with_suffix(".md").unwrap();
writeln!(tmp, "# Hello\n\nWorld").unwrap();
let reg = ParserRegistry::new();
let doc = reg.parse_file(tmp.path()).unwrap().unwrap();
assert_eq!(doc.source_type, SourceType::Markdown);
assert!(!doc.structure.is_empty());
}
#[cfg(feature = "parser-config")]
#[test]
fn test_registry_parse_file_json() {
let mut tmp = NamedTempFile::with_suffix(".json").unwrap();
write!(tmp, r#"{{"key": "value"}}"#).unwrap();
let reg = ParserRegistry::new();
let doc = reg.parse_file(tmp.path()).unwrap().unwrap();
assert_eq!(doc.source_type, SourceType::Json);
}
#[cfg(feature = "parser-markdown")]
#[test]
fn test_registry_parse_content() {
let reg = ParserRegistry::new();
let doc = reg
.parse_content(Path::new("test.md"), "# Hello\n\nWorld")
.unwrap()
.unwrap();
assert_eq!(doc.source_type, SourceType::Markdown);
assert!(!doc.structure.is_empty());
}
#[test]
fn test_registry_unsupported_extension() {
let tmp = NamedTempFile::with_suffix(".png").unwrap();
let reg = ParserRegistry::new();
assert!(reg.parse_file(tmp.path()).unwrap().is_none());
}
#[test]
fn test_registry_no_extension() {
let reg = ParserRegistry::new();
assert!(!reg.supports(Path::new("Makefile_no_ext")));
}
#[test]
fn test_registry_case_insensitive_ext() {
let reg = ParserRegistry::new();
#[cfg(feature = "parser-markdown")]
assert!(reg.supports(Path::new("README.MD")));
#[cfg(feature = "parser-html")]
assert!(reg.supports(Path::new("page.HTML")));
#[cfg(feature = "parser-config")]
assert!(reg.supports(Path::new("data.JSON")));
}
}