feat: complete namespace support (Podcast 2.0, Media RSS, GeoRSS) (#35)

* feat(podcast): add Podcast 2.0 chapters, soundbites and iTunes complete/new-feed-url

Phase 1 of namespace completion:

- Add PodcastChapters type for podcast:chapters element
- Add PodcastSoundbite type for podcast:soundbite element
- Add PodcastEntryMeta container for entry-level podcast metadata
- Add itunes:complete and itunes:new-feed-url fields to ItunesFeedMeta
- Add DoS limits: max_podcast_transcripts, max_podcast_funding, max_podcast_persons
- Add SSRF security warnings to all URL fields in podcast types
- Optimize parse_duration() and parse_explicit() to avoid allocations
- Add comprehensive tests for new functionality

BREAKING: Entry struct now has `podcast: Option<PodcastEntryMeta>` field

* feat(media): add Media RSS full attributes and podcast:value parsing

Phase 2 of namespace completion:

- Add MediaContent type with full Media RSS spec (medium, bitrate, framerate, expression, isDefault)
- Add MediaThumbnail type with NTP time offset support
- Add PodcastValue and PodcastValueRecipient types for value-for-value monetization
- Implement podcast:value parsing with nested valueRecipient elements
- Add max_value_recipients DoS limit (default: 20)
- Add SSRF security warnings to MediaContent.url and MediaThumbnail.url
- Add media_content_to_enclosure() conversion helper
- Add comprehensive unit tests for all new types

* feat(compat): add compatibility module and feed-level GeoRSS support

Phase 3 (final) of namespace completion:

- Add compat module with Python feedparser compatibility helpers:
  - normalize_version() converts FeedVersion to Python format
  - format_duration() converts seconds to HH:MM:SS
  - is_valid_version() validates version identifiers
- Add geo field to FeedMeta for feed-level geographic data
- Add handle_feed_element() to GeoRSS namespace handler
- Add is_georss_tag() helper to parser common module
- Integrate GeoRSS parsing at channel level in RSS and RSS 1.0 parsers
- Add comprehensive tests for all new functionality

* fix: resolve CI lint and formatting issues

- Add #![allow(missing_docs)] to test file
- Fix clippy warnings (float_cmp, format_push_string)
- Apply rustfmt formatting fixes

* fix: export PodcastValue and PodcastValueRecipient types

Author: bug-ops

crates/feedparser-rs-core/src/compat/mod.rs

@@ -1,6 +1,187 @@
-// Compatibility utilities for feedparser API
-//
-// This module provides utilities to ensure API compatibility with
-// Python's feedparser library.
+//! Compatibility utilities for feedparser API
+//!
+//! This module provides utilities to ensure API compatibility with
+//! Python's feedparser library.
 
-// TODO: Implement in later phases as needed
+use crate::types::FeedVersion;
+
+/// Normalize feed type string to Python feedparser format
+///
+/// Converts version enum to Python feedparser-compatible string format:
+/// - "RSS 2.0" -> "rss20"
+/// - "Atom 1.0" -> "atom10"
+/// - etc.
+///
+/// # Arguments
+///
+/// * `version` - Feed version to normalize
+///
+/// # Returns
+///
+/// Normalized version string compatible with Python feedparser
+///
+/// # Examples
+///
+/// ```
+/// use feedparser_rs::{compat::normalize_version, FeedVersion};
+///
+/// assert_eq!(normalize_version(FeedVersion::Rss20), "rss20");
+/// assert_eq!(normalize_version(FeedVersion::Atom10), "atom10");
+/// assert_eq!(normalize_version(FeedVersion::Unknown), "");
+/// ```
+#[must_use]
+pub fn normalize_version(version: FeedVersion) -> String {
+    version.as_str().to_string()
+}
+
+/// Convert duration in seconds to HH:MM:SS format
+///
+/// Formats duration for display in podcast feeds and other contexts
+/// where human-readable time format is needed.
+///
+/// # Arguments
+///
+/// * `seconds` - Duration in seconds
+///
+/// # Returns
+///
+/// Duration string in HH:MM:SS format
+///
+/// # Examples
+///
+/// ```
+/// use feedparser_rs::compat::format_duration;
+///
+/// assert_eq!(format_duration(0), "0:00:00");
+/// assert_eq!(format_duration(90), "0:01:30");
+/// assert_eq!(format_duration(3661), "1:01:01");
+/// assert_eq!(format_duration(36000), "10:00:00");
+/// ```
+#[must_use]
+pub fn format_duration(seconds: u32) -> String {
+    let hours = seconds / 3600;
+    let minutes = (seconds % 3600) / 60;
+    let secs = seconds % 60;
+    format!("{hours}:{minutes:02}:{secs:02}")
+}
+
+/// Check if a string is a valid feed version identifier
+///
+/// Validates whether a version string matches one of the known
+/// feed format versions supported by feedparser.
+///
+/// # Arguments
+///
+/// * `version` - Version string to validate
+///
+/// # Returns
+///
+/// `true` if version is valid, `false` otherwise
+///
+/// # Examples
+///
+/// ```
+/// use feedparser_rs::compat::is_valid_version;
+///
+/// assert!(is_valid_version("rss20"));
+/// assert!(is_valid_version("atom10"));
+/// assert!(is_valid_version("json11"));
+/// assert!(!is_valid_version("invalid"));
+/// assert!(!is_valid_version(""));
+/// ```
+#[must_use]
+pub fn is_valid_version(version: &str) -> bool {
+    matches!(
+        version,
+        "rss090"
+            | "rss091"
+            | "rss092"
+            | "rss10"
+            | "rss20"
+            | "atom03"
+            | "atom10"
+            | "json10"
+            | "json11"
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_normalize_version() {
+        assert_eq!(normalize_version(FeedVersion::Rss20), "rss20");
+        assert_eq!(normalize_version(FeedVersion::Rss10), "rss10");
+        assert_eq!(normalize_version(FeedVersion::Atom10), "atom10");
+        assert_eq!(normalize_version(FeedVersion::Atom03), "atom03");
+        assert_eq!(normalize_version(FeedVersion::JsonFeed10), "json10");
+        assert_eq!(normalize_version(FeedVersion::JsonFeed11), "json11");
+        assert_eq!(normalize_version(FeedVersion::Unknown), "");
+    }
+
+    #[test]
+    fn test_format_duration_zero() {
+        assert_eq!(format_duration(0), "0:00:00");
+    }
+
+    #[test]
+    fn test_format_duration_seconds_only() {
+        assert_eq!(format_duration(30), "0:00:30");
+        assert_eq!(format_duration(59), "0:00:59");
+    }
+
+    #[test]
+    fn test_format_duration_minutes() {
+        assert_eq!(format_duration(60), "0:01:00");
+        assert_eq!(format_duration(90), "0:01:30");
+        assert_eq!(format_duration(150), "0:02:30");
+        assert_eq!(format_duration(3599), "0:59:59");
+    }
+
+    #[test]
+    fn test_format_duration_hours() {
+        assert_eq!(format_duration(3600), "1:00:00");
+        assert_eq!(format_duration(3661), "1:01:01");
+        assert_eq!(format_duration(7200), "2:00:00");
+        assert_eq!(format_duration(36000), "10:00:00");
+    }
+
+    #[test]
+    fn test_format_duration_large() {
+        assert_eq!(format_duration(86399), "23:59:59");
+        assert_eq!(format_duration(86400), "24:00:00");
+        assert_eq!(format_duration(90061), "25:01:01");
+    }
+
+    #[test]
+    fn test_is_valid_version_valid() {
+        assert!(is_valid_version("rss090"));
+        assert!(is_valid_version("rss091"));
+        assert!(is_valid_version("rss092"));
+        assert!(is_valid_version("rss10"));
+        assert!(is_valid_version("rss20"));
+        assert!(is_valid_version("atom03"));
+        assert!(is_valid_version("atom10"));
+        assert!(is_valid_version("json10"));
+        assert!(is_valid_version("json11"));
+    }
+
+    #[test]
+    fn test_is_valid_version_invalid() {
+        assert!(!is_valid_version(""));
+        assert!(!is_valid_version("invalid"));
+        assert!(!is_valid_version("rss30"));
+        assert!(!is_valid_version("atom20"));
+        assert!(!is_valid_version("RSS20")); // Case sensitive
+        assert!(!is_valid_version("json12"));
+        assert!(!is_valid_version("rdf"));
+    }
+
+    #[test]
+    fn test_is_valid_version_edge_cases() {
+        assert!(!is_valid_version(" rss20"));
+        assert!(!is_valid_version("rss20 "));
+        assert!(!is_valid_version("rss 20"));
+    }
+}

crates/feedparser-rs-core/src/lib.rs

@@ -38,7 +38,8 @@
 //! for representing parsed feed data. The main entry point is the [`parse`] function which
 //! automatically detects feed format and returns parsed results.
 
-mod compat;
+/// Compatibility utilities for Python feedparser API
+pub mod compat;
 mod error;
 #[cfg(feature = "http")]
 /// HTTP client module for fetching feeds from URLs
@@ -68,8 +69,9 @@ pub use parser::{detect_format, parse, parse_with_limits};
 pub use types::{
     Content, Enclosure, Entry, FeedMeta, FeedVersion, Generator, Image, ItunesCategory,
     ItunesEntryMeta, ItunesFeedMeta, ItunesOwner, LimitedCollectionExt, Link, ParsedFeed, Person,
-    PodcastFunding, PodcastMeta, PodcastPerson, PodcastTranscript, Source, Tag, TextConstruct,
-    TextType, parse_duration, parse_explicit,
+    PodcastChapters, PodcastEntryMeta, PodcastFunding, PodcastMeta, PodcastPerson,
+    PodcastSoundbite, PodcastTranscript, PodcastValue, PodcastValueRecipient, Source, Tag,
+    TextConstruct, TextType, parse_duration, parse_explicit,
 };
 
 pub use namespace::syndication::{SyndicationMeta, UpdatePeriod};

crates/feedparser-rs-core/src/limits.rs

@@ -107,6 +107,42 @@ pub struct ParserLimits {
     ///
     /// Default: 64 KB
     pub max_attribute_length: usize,
+
+    /// Maximum number of podcast soundbites per entry
+    ///
+    /// Podcast 2.0 soundbite elements for shareable clips.
+    ///
+    /// Default: 10 soundbites
+    pub max_podcast_soundbites: usize,
+
+    /// Maximum number of podcast transcripts per entry
+    ///
+    /// Podcast 2.0 transcript elements.
+    ///
+    /// Default: 20 transcripts
+    pub max_podcast_transcripts: usize,
+
+    /// Maximum number of podcast funding elements per feed
+    ///
+    /// Podcast 2.0 funding elements for donation links.
+    ///
+    /// Default: 20 funding elements
+    pub max_podcast_funding: usize,
+
+    /// Maximum number of podcast person elements per entry
+    ///
+    /// Podcast 2.0 person elements for hosts, guests, etc.
+    ///
+    /// Default: 50 persons
+    pub max_podcast_persons: usize,
+
+    /// Maximum number of podcast value recipients per feed
+    ///
+    /// Podcast 2.0 value recipients for payment splitting.
+    /// Prevents `DoS` from feeds with excessive recipient lists.
+    ///
+    /// Default: 20 recipients
+    pub max_value_recipients: usize,
 }
 
 impl Default for ParserLimits {
@@ -129,6 +165,11 @@ impl Default for ParserLimits {
             max_text_length: 10 * 1024 * 1024,      // 10 MB
             max_feed_size_bytes: 100 * 1024 * 1024, // 100 MB
             max_attribute_length: 64 * 1024,        // 64 KB
+            max_podcast_soundbites: 10,
+            max_podcast_transcripts: 20,
+            max_podcast_funding: 20,
+            max_podcast_persons: 50,
+            max_value_recipients: 20,
         }
     }
 }
@@ -163,6 +204,11 @@ impl ParserLimits {
             max_text_length: 1024 * 1024,          // 1 MB
             max_feed_size_bytes: 10 * 1024 * 1024, // 10 MB
             max_attribute_length: 8 * 1024,        // 8 KB
+            max_podcast_soundbites: 5,
+            max_podcast_transcripts: 5,
+            max_podcast_funding: 5,
+            max_podcast_persons: 10,
+            max_value_recipients: 5,
         }
     }
 
@@ -195,6 +241,11 @@ impl ParserLimits {
             max_text_length: 50 * 1024 * 1024,      // 50 MB
             max_feed_size_bytes: 500 * 1024 * 1024, // 500 MB
             max_attribute_length: 256 * 1024,       // 256 KB
+            max_podcast_soundbites: 50,
+            max_podcast_transcripts: 100,
+            max_podcast_funding: 50,
+            max_podcast_persons: 200,
+            max_value_recipients: 50,
         }
     }
 
@@ -393,4 +444,49 @@ mod tests {
         assert!(msg.contains("200000000"));
         assert!(msg.contains("100000000"));
     }
+
+    #[test]
+    fn test_max_value_recipients_default() {
+        let limits = ParserLimits::default();
+        assert_eq!(limits.max_value_recipients, 20);
+    }
+
+    #[test]
+    fn test_max_value_recipients_strict() {
+        let limits = ParserLimits::strict();
+        assert_eq!(limits.max_value_recipients, 5);
+        assert!(limits.max_value_recipients < ParserLimits::default().max_value_recipients);
+    }
+
+    #[test]
+    fn test_max_value_recipients_permissive() {
+        let limits = ParserLimits::permissive();
+        assert_eq!(limits.max_value_recipients, 50);
+        assert!(limits.max_value_recipients > ParserLimits::default().max_value_recipients);
+    }
+
+    #[test]
+    fn test_value_recipients_limit_enforcement() {
+        let limits = ParserLimits::default();
+
+        // Within limit
+        assert!(
+            limits
+                .check_collection_size(19, limits.max_value_recipients, "value_recipients")
+                .is_ok()
+        );
+
+        // At limit
+        assert!(
+            limits
+                .check_collection_size(20, limits.max_value_recipients, "value_recipients")
+                .is_err()
+        );
+
+        // Exceeds limit
+        let result =
+            limits.check_collection_size(21, limits.max_value_recipients, "value_recipients");
+        assert!(result.is_err());
+        assert!(matches!(result, Err(LimitError::CollectionTooLarge { .. })));
+    }
 }