use scraper::{Html, Selector};
use crate::domain::services::extraction_service::ExtractionService;
use super::traits::{ContentExtractor, ExtractError, ExtractedContent, PageType};
#[derive(Debug, Clone, Default)]
pub struct CssRuleExtractor;
impl CssRuleExtractor {
pub fn new() -> Self {
Self
}
fn extract_title(document: &Html) -> Option<String> {
if let Ok(selector) = Selector::parse("title") {
if let Some(element) = document.select(&selector).next() {
let text = element
.text()
.collect::<Vec<_>>()
.join("")
.trim()
.to_string();
if !text.is_empty() {
return Some(text);
}
}
}
if let Ok(selector) = Selector::parse("h1") {
if let Some(element) = document.select(&selector).next() {
let text = element
.text()
.collect::<Vec<_>>()
.join("")
.trim()
.to_string();
if !text.is_empty() {
return Some(text);
}
}
}
None
}
fn extract_author(document: &Html) -> Option<String> {
let selector = Selector::parse(r#"meta[name="author"]"#).ok()?;
let element = document.select(&selector).next()?;
let content = element.value().attr("content")?;
let trimmed = content.trim().to_string();
if trimmed.is_empty() {
None
} else {
Some(trimmed)
}
}
}
impl ContentExtractor for CssRuleExtractor {
fn extract(&self, html: &str, _url: &str) -> Result<ExtractedContent, ExtractError> {
let trimmed_html = html.trim();
if trimmed_html.is_empty() {
return Err(ExtractError::NoContent);
}
let text = ExtractionService::get_clean_text(html);
let text = text.trim();
if text.is_empty() {
return Err(ExtractError::NoContent);
}
let document = Html::parse_document(html);
let title = Self::extract_title(&document);
let author = Self::extract_author(&document);
Ok(ExtractedContent {
text: text.to_string(),
html: None,
title,
author,
confidence: 0.5,
page_type: PageType::Unknown,
})
}
fn name(&self) -> &'static str {
"css-rule"
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn extracts_main_content_and_strips_nav_footer_aside() {
let html = r#"<html><head><title>Test Article</title>
<meta name="author" content="Kirky.X"></head>
<body>
<nav>Home About</nav>
<aside>Sidebar content</aside>
<article><p>This is the main content of the article.</p>
<p>Second paragraph with more text.</p></article>
<footer>Copyright 2025</footer>
</body></html>"#;
let extractor = CssRuleExtractor::new();
let result = extractor
.extract(html, "https://example.com/a")
.expect("extract ok");
assert!(!result.text.is_empty(), "text should not be empty");
assert!(
result.text.contains("main content"),
"text should contain main content, got: {}",
result.text
);
assert!(
result.text.contains("Second paragraph"),
"text should contain second paragraph"
);
assert!(
!result.text.contains("Home About"),
"nav should be stripped, got: {}",
result.text
);
assert!(
!result.text.contains("Copyright 2025"),
"footer should be stripped"
);
assert!(
!result.text.contains("Sidebar content"),
"aside should be stripped"
);
}
#[test]
fn extracts_title_from_title_tag() {
let html = "<html><head><title>Page Title</title></head><body><p>content</p></body></html>";
let result = CssRuleExtractor::new()
.extract(html, "https://example.com/")
.expect("extract ok");
assert_eq!(result.title.as_deref(), Some("Page Title"));
}
#[test]
fn extracts_title_from_h1_when_title_missing() {
let html = "<html><body><h1>Heading Title</h1><p>content</p></body></html>";
let result = CssRuleExtractor::new()
.extract(html, "https://example.com/")
.expect("extract ok");
assert_eq!(result.title.as_deref(), Some("Heading Title"));
}
#[test]
fn returns_none_title_when_no_title_or_h1() {
let html = "<html><body><p>just some content here</p></body></html>";
let result = CssRuleExtractor::new()
.extract(html, "https://example.com/")
.expect("extract ok");
assert!(result.title.is_none(), "title should be None");
}
#[test]
fn extracts_author_from_meta_tag() {
let html = r#"<html><head>
<meta name="author" content="Author Name">
</head><body><p>content</p></body></html>"#;
let result = CssRuleExtractor::new()
.extract(html, "https://example.com/")
.expect("extract ok");
assert_eq!(result.author.as_deref(), Some("Author Name"));
}
#[test]
fn returns_error_for_empty_html() {
let result = CssRuleExtractor::new().extract("", "https://example.com/");
assert!(matches!(result, Err(ExtractError::NoContent)));
}
#[test]
fn returns_error_for_whitespace_only_html() {
let result = CssRuleExtractor::new().extract(" \n\t ", "https://example.com/");
assert!(matches!(result, Err(ExtractError::NoContent)));
}
#[test]
fn returns_error_when_clean_text_is_empty() {
let html =
"<html><body><nav>nav</nav><aside>aside</aside><footer>footer</footer></body></html>";
let result = CssRuleExtractor::new().extract(html, "https://example.com/");
assert!(matches!(result, Err(ExtractError::NoContent)));
}
#[test]
fn confidence_is_fixed_at_0_5() {
let html = "<html><body><p>some content</p></body></html>";
let result = CssRuleExtractor::new()
.extract(html, "https://example.com/")
.expect("extract ok");
assert!((result.confidence - 0.5).abs() < f32::EPSILON);
assert!(
result.should_fallback_to_llm(),
"0.5 should trigger fallback"
);
}
#[test]
fn page_type_is_unknown() {
let html = "<html><body><p>some content</p></body></html>";
let result = CssRuleExtractor::new()
.extract(html, "https://example.com/")
.expect("extract ok");
assert_eq!(result.page_type, PageType::Unknown);
}
#[test]
fn name_returns_css_rule() {
assert_eq!(CssRuleExtractor::new().name(), "css-rule");
}
#[test]
fn default_equals_new() {
let a = CssRuleExtractor::new();
let b = CssRuleExtractor;
let html = "<p>same content</p>";
let ra = a
.extract(html, "https://example.com/")
.expect("a extract ok");
let rb = b
.extract(html, "https://example.com/")
.expect("b extract ok");
assert_eq!(ra.text, rb.text);
assert_eq!(ra.confidence, rb.confidence);
}
#[test]
fn trait_object_dispatch_works() {
let extractor: Box<dyn ContentExtractor> = Box::new(CssRuleExtractor::new());
let html = "<html><body><p>via trait</p></body></html>";
let result = extractor
.extract(html, "https://example.com/")
.expect("trait dispatch ok");
assert!(result.text.contains("via trait"));
assert_eq!(extractor.name(), "css-rule");
}
#[test]
fn handles_very_long_html() {
let mut body = String::from("<html><body>");
for _ in 0..10_000 {
body.push_str("<p>paragraph content here. </p>");
}
body.push_str("</body></html>");
let result = CssRuleExtractor::new()
.extract(&body, "https://example.com/long")
.expect("extract ok");
assert!(!result.text.is_empty());
assert!(result.text.contains("paragraph content"));
}
#[test]
fn handles_malformed_html() {
let html = "<html><body><p>unclosed paragraph <b>bold text</body></html>";
let result = CssRuleExtractor::new()
.extract(html, "https://example.com/")
.expect("extract ok");
assert!(result.text.contains("unclosed paragraph") || result.text.contains("bold text"));
}
}