feedparser-rs 0.4.7__tar.gz → 0.4.8__tar.gz

{feedparser_rs-0.4.7 → feedparser_rs-0.4.8}/Cargo.lock

@@ -600,7 +600,7 @@ checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
 
 [[package]]
 name = "feedparser-rs"
-version = "0.4.7"
+version = "0.4.8"
 dependencies = [
  "ammonia",
  "chrono",
@@ -623,7 +623,7 @@ dependencies = [
 
 [[package]]
 name = "feedparser-rs-node"
-version = "0.4.7"
+version = "0.4.8"
 dependencies = [
  "feedparser-rs",
  "napi",
@@ -633,7 +633,7 @@ dependencies = [
 
 [[package]]
 name = "feedparser-rs-py"
-version = "0.4.7"
+version = "0.4.8"
 dependencies = [
  "chrono",
  "feedparser-rs",

{feedparser_rs-0.4.7 → feedparser_rs-0.4.8}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/feedparser-rs-core", "crates/feedparser-rs-py"]
 resolver = "2"
 
 [workspace.package]
-version = "0.4.7"
+version = "0.4.8"
 edition = "2024"
 rust-version = "1.88.0"
 authors = ["bug-ops"]

{feedparser_rs-0.4.7 → feedparser_rs-0.4.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: feedparser-rs
-Version: 0.4.7
+Version: 0.4.8
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{feedparser_rs-0.4.7 → feedparser_rs-0.4.8}/crates/feedparser-rs-core/src/lib.rs

@@ -188,9 +188,9 @@ pub use limits::{LimitError, ParserLimits};
 pub use options::ParseOptions;
 pub use parser::{detect_format, parse, parse_with_limits};
 pub use types::{
-    Content, Email, Enclosure, Entry, FeedMeta, FeedVersion, Generator, Image, ItunesCategory,
-    ItunesEntryMeta, ItunesFeedMeta, ItunesOwner, LimitedCollectionExt, Link, MediaContent,
-    MediaThumbnail, MimeType, ParsedFeed, Person, PodcastChapters, PodcastEntryMeta,
+    Content, Email, Enclosure, Entry, FeedMeta, FeedVersion, Generator, Image, InReplyTo,
+    ItunesCategory, ItunesEntryMeta, ItunesFeedMeta, ItunesOwner, LimitedCollectionExt, Link,
+    MediaContent, MediaThumbnail, MimeType, ParsedFeed, Person, PodcastChapters, PodcastEntryMeta,
     PodcastFunding, PodcastMeta, PodcastPerson, PodcastSoundbite, PodcastTranscript, PodcastValue,
     PodcastValueRecipient, Source, Tag, TextConstruct, TextType, Url, parse_duration,
     parse_explicit,

{feedparser_rs-0.4.7 → feedparser_rs-0.4.8}/crates/feedparser-rs-core/src/namespace/mod.rs

@@ -8,6 +8,8 @@
 /// - **Media RSS** (`media:`) - Multimedia content
 /// - **GeoRSS** (`georss:`) - Geographic location data
 /// - **Creative Commons** (`cc:`) - License information
+/// - **Slash** (`slash:`) - Comment count
+/// - **WFW** (`wfw:`) - Comment RSS URL
 ///
 /// # Usage
 ///
@@ -35,8 +37,12 @@ pub mod dublin_core;
 pub mod georss;
 /// Media RSS specification
 pub mod media_rss;
+/// Slash and WFW namespace (comment count + comment RSS URL)
+pub mod slash;
 /// Syndication Module for RSS 1.0
 pub mod syndication;
+/// Atom Threading Extensions (RFC 4685)
+pub mod threading;
 
 /// Common namespace URIs used in feeds
 pub mod namespaces {
@@ -75,6 +81,15 @@ pub mod namespaces {
 
     /// Creative Commons (legacy Userland)
     pub const CREATIVE_COMMONS: &str = "http://backend.userland.com/creativeCommonsRssModule";
+
+    /// Atom Threading Extensions (RFC 4685)
+    pub const THREADING: &str = "http://purl.org/syndication/thread/1.0";
+
+    /// Slash namespace
+    pub const SLASH: &str = "http://purl.org/rss/1.0/modules/slash/";
+
+    /// WFW (Well-Formed Web) namespace
+    pub const WFW: &str = "http://wellformedweb.org/CommentAPI/";
 }
 
 /// Get namespace URI for a common prefix
@@ -99,6 +114,9 @@ pub fn get_namespace_uri(prefix: &str) -> Option<&'static str> {
         "georss" => Some(namespaces::GEORSS),
         "cc" => Some(namespaces::CC),
         "creativeCommons" => Some(namespaces::CREATIVE_COMMONS),
+        "thr" => Some(namespaces::THREADING),
+        "slash" => Some(namespaces::SLASH),
+        "wfw" => Some(namespaces::WFW),
         _ => None,
     }
 }
@@ -125,6 +143,9 @@ pub fn get_namespace_prefix(uri: &str) -> Option<&'static str> {
         namespaces::GEORSS => Some("georss"),
         namespaces::CC => Some("cc"),
         namespaces::CREATIVE_COMMONS => Some("creativeCommons"),
+        namespaces::THREADING => Some("thr"),
+        namespaces::SLASH => Some("slash"),
+        namespaces::WFW => Some("wfw"),
         _ => None,
     }
 }

feedparser_rs-0.4.8/crates/feedparser-rs-core/src/namespace/slash.rs

@@ -0,0 +1,117 @@
+/// Slash namespace — `http://purl.org/rss/1.0/modules/slash/`
+/// WFW (Well-Formed Web) namespace — `http://wellformedweb.org/CommentAPI/`
+///
+/// These namespaces are commonly used together in `WordPress`, `Blogger`, and
+/// `Movable Type` feeds to expose comment metadata.
+///
+/// - `slash:comments` — integer count of comments on an entry
+/// - `wfw:commentRss` — URL of the entry's comment RSS feed
+use crate::types::Entry;
+
+/// Slash namespace URI
+pub const SLASH_NAMESPACE: &str = "http://purl.org/rss/1.0/modules/slash/";
+
+/// WFW namespace URI
+pub const WFW_NAMESPACE: &str = "http://wellformedweb.org/CommentAPI/";
+
+/// Handle a Slash namespace element at entry level
+///
+/// # Arguments
+///
+/// * `element` - Local name of the element (without namespace prefix)
+/// * `text` - Text content of the element
+/// * `entry` - Entry to update
+pub fn handle_slash_entry_element(element: &str, text: &str, entry: &mut Entry) {
+    if element == "comments" {
+        // Ignore non-integer values silently (bozo pattern: keep parsing)
+        entry.slash_comments = text.trim().parse::<u32>().ok();
+    }
+}
+
+/// Handle a WFW namespace element at entry level
+///
+/// # Arguments
+///
+/// * `element` - Local name of the element (without namespace prefix)
+/// * `text` - Text content of the element
+/// * `entry` - Entry to update
+pub fn handle_wfw_entry_element(element: &str, text: &str, entry: &mut Entry) {
+    if element == "commentRss" || element == "commentrss" {
+        entry.wfw_comment_rss = Some(text.trim().to_string());
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_slash_comments_integer() {
+        let mut entry = Entry::default();
+        handle_slash_entry_element("comments", "42", &mut entry);
+        assert_eq!(entry.slash_comments, Some(42));
+    }
+
+    #[test]
+    fn test_slash_comments_with_whitespace() {
+        let mut entry = Entry::default();
+        handle_slash_entry_element("comments", "  7  ", &mut entry);
+        assert_eq!(entry.slash_comments, Some(7));
+    }
+
+    #[test]
+    fn test_slash_comments_zero() {
+        let mut entry = Entry::default();
+        handle_slash_entry_element("comments", "0", &mut entry);
+        assert_eq!(entry.slash_comments, Some(0));
+    }
+
+    #[test]
+    fn test_slash_comments_invalid_is_ignored() {
+        let mut entry = Entry::default();
+        handle_slash_entry_element("comments", "not-a-number", &mut entry);
+        assert_eq!(entry.slash_comments, None);
+    }
+
+    #[test]
+    fn test_slash_unknown_element_ignored() {
+        let mut entry = Entry::default();
+        handle_slash_entry_element("section", "tech", &mut entry);
+        assert_eq!(entry.slash_comments, None);
+    }
+
+    #[test]
+    fn test_wfw_comment_rss() {
+        let mut entry = Entry::default();
+        handle_wfw_entry_element(
+            "commentRss",
+            "https://example.com/post/comments/feed/",
+            &mut entry,
+        );
+        assert_eq!(
+            entry.wfw_comment_rss.as_deref(),
+            Some("https://example.com/post/comments/feed/")
+        );
+    }
+
+    #[test]
+    fn test_wfw_comment_rss_lowercase_variant() {
+        let mut entry = Entry::default();
+        handle_wfw_entry_element(
+            "commentrss",
+            "https://example.com/post/comments/feed/",
+            &mut entry,
+        );
+        assert_eq!(
+            entry.wfw_comment_rss.as_deref(),
+            Some("https://example.com/post/comments/feed/")
+        );
+    }
+
+    #[test]
+    fn test_wfw_unknown_element_ignored() {
+        let mut entry = Entry::default();
+        handle_wfw_entry_element("other", "value", &mut entry);
+        assert_eq!(entry.wfw_comment_rss, None);
+    }
+}

feedparser_rs-0.4.8/crates/feedparser-rs-core/src/namespace/threading.rs

@@ -0,0 +1,264 @@
+/// Atom Threading Extensions (RFC 4685) namespace handler
+///
+/// Namespace URI: `http://purl.org/syndication/thread/1.0`
+/// Prefix: `thr`
+///
+/// Handles two elements:
+/// - `thr:in-reply-to` — attribute-only element referencing the parent entry
+/// - `thr:total` — text element with total response count
+use crate::types::{Entry, InReplyTo, MimeType, SmallString, Url};
+
+/// Atom Threading Extensions namespace URI
+pub const THREADING_NAMESPACE: &str = "http://purl.org/syndication/thread/1.0";
+
+/// Normalize attribute value: empty string after trim becomes None
+#[inline]
+fn non_empty(s: &str) -> Option<&str> {
+    let trimmed = s.trim();
+    if trimmed.is_empty() {
+        None
+    } else {
+        Some(trimmed)
+    }
+}
+
+/// Build an `InReplyTo` from its four optional fields.
+///
+/// Returns `None` only if ALL fields are `None` (fully empty element).
+#[inline]
+fn build_in_reply_to(
+    ref_: Option<SmallString>,
+    href: Option<Url>,
+    type_: Option<MimeType>,
+    source: Option<Url>,
+) -> Option<InReplyTo> {
+    if ref_.is_none() && href.is_none() && type_.is_none() && source.is_none() {
+        return None;
+    }
+    Some(InReplyTo {
+        ref_,
+        href,
+        type_,
+        source,
+    })
+}
+
+/// Parse `thr:in-reply-to` from a quick-xml attribute iterator (Atom and RSS 1.0 parser paths)
+///
+/// Returns `None` only if ALL fields are `None` after normalization (fully empty element).
+/// Returns `Some(InReplyTo)` even if `ref` is missing, to tolerate malformed feeds.
+///
+/// # Arguments
+///
+/// * `attrs` - Iterator over quick-xml attributes (from `element.attributes().flatten()`)
+/// * `max_attr_len` - Maximum attribute value length for `DoS` protection
+pub fn parse_in_reply_to_from_attrs<'a>(
+    attrs: impl Iterator<Item = quick_xml::events::attributes::Attribute<'a>>,
+    max_attr_len: usize,
+) -> Option<InReplyTo> {
+    let mut ref_ = None;
+    let mut href = None;
+    let mut type_ = None;
+    let mut source = None;
+
+    for attr in attrs {
+        if attr.value.len() > max_attr_len {
+            continue;
+        }
+        let Ok(value) = attr.unescape_value() else {
+            continue;
+        };
+        match attr.key.as_ref() {
+            b"ref" => ref_ = non_empty(&value).map(|s| s.to_string().into()),
+            b"href" => href = non_empty(&value).map(|s| s.to_string().into()),
+            b"type" => type_ = non_empty(&value).map(|s| s.to_string().into()),
+            b"source" => source = non_empty(&value).map(|s| s.to_string().into()),
+            _ => {}
+        }
+    }
+
+    build_in_reply_to(ref_, href, type_, source)
+}
+
+/// Parse `thr:in-reply-to` from collected attributes (RSS 2.0 parser path)
+///
+/// Returns `None` only if ALL fields are `None` after normalization.
+///
+/// # Arguments
+///
+/// * `attrs` - Slice of collected `(key_bytes, value_string)` attribute pairs
+/// * `max_attr_len` - Maximum attribute value length for `DoS` protection
+pub fn parse_in_reply_to_from_collected(
+    attrs: &[(Vec<u8>, String)],
+    max_attr_len: usize,
+) -> Option<InReplyTo> {
+    let mut ref_ = None;
+    let mut href = None;
+    let mut type_ = None;
+    let mut source = None;
+
+    for (key, value) in attrs {
+        if value.len() > max_attr_len {
+            continue;
+        }
+        match key.as_slice() {
+            b"ref" => ref_ = non_empty(value).map(|s| s.to_string().into()),
+            b"href" => href = non_empty(value).map(|s| s.to_string().into()),
+            b"type" => type_ = non_empty(value).map(|s| s.to_string().into()),
+            b"source" => source = non_empty(value).map(|s| s.to_string().into()),
+            _ => {}
+        }
+    }
+
+    build_in_reply_to(ref_, href, type_, source)
+}
+
+/// Handle `thr:total` text content
+///
+/// Parses non-negative integer from text. Silently ignores non-numeric, negative,
+/// overflow, empty, and whitespace-only values (consistent with how `parse_duration`
+/// handles invalid input throughout the codebase).
+///
+/// # Arguments
+///
+/// * `text` - Text content of the `thr:total` element
+/// * `entry` - Entry to update with the parsed count
+pub fn handle_total(text: &str, entry: &mut Entry) {
+    entry.thr_total = text.trim().parse::<u32>().ok();
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_handle_total_valid() {
+        let mut entry = Entry::default();
+        handle_total("15", &mut entry);
+        assert_eq!(entry.thr_total, Some(15));
+    }
+
+    #[test]
+    fn test_handle_total_with_whitespace() {
+        let mut entry = Entry::default();
+        handle_total("  42  ", &mut entry);
+        assert_eq!(entry.thr_total, Some(42));
+    }
+
+    #[test]
+    fn test_handle_total_zero() {
+        let mut entry = Entry::default();
+        handle_total("0", &mut entry);
+        assert_eq!(entry.thr_total, Some(0));
+    }
+
+    #[test]
+    fn test_handle_total_non_numeric() {
+        let mut entry = Entry::default();
+        handle_total("abc", &mut entry);
+        assert_eq!(entry.thr_total, None);
+    }
+
+    #[test]
+    fn test_handle_total_negative() {
+        let mut entry = Entry::default();
+        handle_total("-5", &mut entry);
+        assert_eq!(entry.thr_total, None);
+    }
+
+    #[test]
+    fn test_handle_total_overflow() {
+        let mut entry = Entry::default();
+        handle_total("99999999999999", &mut entry);
+        assert_eq!(entry.thr_total, None);
+    }
+
+    #[test]
+    fn test_handle_total_empty() {
+        let mut entry = Entry::default();
+        handle_total("", &mut entry);
+        assert_eq!(entry.thr_total, None);
+    }
+
+    #[test]
+    fn test_handle_total_whitespace_only() {
+        let mut entry = Entry::default();
+        handle_total("   ", &mut entry);
+        assert_eq!(entry.thr_total, None);
+    }
+
+    #[test]
+    fn test_parse_in_reply_to_from_collected_full() {
+        let attrs = vec![
+            (b"ref".to_vec(), "tag:example.com,2024:post/1".to_string()),
+            (b"href".to_vec(), "https://example.com/post/1".to_string()),
+            (b"type".to_vec(), "text/html".to_string()),
+            (
+                b"source".to_vec(),
+                "https://example.com/feed.xml".to_string(),
+            ),
+        ];
+        let result = parse_in_reply_to_from_collected(&attrs, 1024);
+        assert!(result.is_some());
+        let irt = result.unwrap();
+        assert_eq!(irt.ref_.as_deref(), Some("tag:example.com,2024:post/1"));
+        assert_eq!(irt.href.as_deref(), Some("https://example.com/post/1"));
+        assert_eq!(irt.type_.as_deref(), Some("text/html"));
+        assert_eq!(irt.source.as_deref(), Some("https://example.com/feed.xml"));
+    }
+
+    #[test]
+    fn test_parse_in_reply_to_from_collected_empty_ref() {
+        let attrs = vec![
+            (b"ref".to_vec(), String::new()),
+            (b"href".to_vec(), "https://example.com/post/1".to_string()),
+        ];
+        let result = parse_in_reply_to_from_collected(&attrs, 1024);
+        assert!(result.is_some());
+        let irt = result.unwrap();
+        // Empty ref should be normalized to None
+        assert!(irt.ref_.is_none());
+        assert_eq!(irt.href.as_deref(), Some("https://example.com/post/1"));
+    }
+
+    #[test]
+    fn test_parse_in_reply_to_from_collected_all_empty() {
+        let attrs = vec![
+            (b"ref".to_vec(), String::new()),
+            (b"href".to_vec(), String::new()),
+            (b"type".to_vec(), "  ".to_string()),
+            (b"source".to_vec(), String::new()),
+        ];
+        let result = parse_in_reply_to_from_collected(&attrs, 1024);
+        // All fields are None -> return None
+        assert!(result.is_none());
+    }
+
+    #[test]
+    fn test_parse_in_reply_to_from_collected_truncated_by_limit() {
+        let attrs = vec![(b"ref".to_vec(), "tag:example.com,2024:post/1".to_string())];
+        let result = parse_in_reply_to_from_collected(&attrs, 5);
+        // Value exceeds max_attr_len, should be skipped -> all None -> None
+        assert!(result.is_none());
+    }
+
+    #[test]
+    fn test_parse_in_reply_to_from_collected_only_ref() {
+        let attrs = vec![(b"ref".to_vec(), "tag:example.com,2024:post/1".to_string())];
+        let result = parse_in_reply_to_from_collected(&attrs, 1024);
+        assert!(result.is_some());
+        let irt = result.unwrap();
+        assert_eq!(irt.ref_.as_deref(), Some("tag:example.com,2024:post/1"));
+        assert!(irt.href.is_none());
+        assert!(irt.type_.is_none());
+        assert!(irt.source.is_none());
+    }
+
+    #[test]
+    fn test_non_empty_normalization() {
+        assert_eq!(non_empty(""), None);
+        assert_eq!(non_empty("  "), None);
+        assert_eq!(non_empty("hello"), Some("hello"));
+        assert_eq!(non_empty("  hello  "), Some("hello"));
+    }
+}