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

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

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

{feedparser_rs-0.4.7 → feedparser_rs-0.5.0}/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.5.0"
 edition = "2024"
 rust-version = "1.88.0"
 authors = ["bug-ops"]

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

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

{feedparser_rs-0.4.7 → feedparser_rs-0.5.0}/crates/feedparser-rs-core/examples/parse_file.rs

@@ -109,7 +109,7 @@ fn parse_rss_example() -> Result<(), Box<dyn std::error::Error>> {
                 if let Some(enclosure_type) = &enc.enclosure_type {
                     println!("        Type: {enclosure_type}");
                 }
-                if let Some(length) = enc.length {
+                if let Some(length) = &enc.length {
                     println!("        Size: {length} bytes");
                 }
             }

{feedparser_rs-0.4.7 → feedparser_rs-0.5.0}/crates/feedparser-rs-core/examples/podcast_feed.rs

@@ -176,10 +176,14 @@ fn display_episodes(feed: &feedparser_rs::ParsedFeed) {
                 if let Some(enclosure_type) = &enc.enclosure_type {
                     println!("    Type: {enclosure_type}");
                 }
-                if let Some(length) = enc.length {
-                    #[allow(clippy::cast_precision_loss)]
-                    let mb = length as f64 / 1_048_576.0;
-                    println!("    Size: {mb:.2} MB ({length} bytes)");
+                if let Some(length) = &enc.length {
+                    if let Ok(bytes) = length.parse::<u64>() {
+                        #[allow(clippy::cast_precision_loss)]
+                        let mb = bytes as f64 / 1_048_576.0;
+                        println!("    Size: {mb:.2} MB ({bytes} bytes)");
+                    } else {
+                        println!("    Size: {length} bytes");
+                    }
                 }
             }
         }

{feedparser_rs-0.4.7 → feedparser_rs-0.5.0}/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.5.0}/crates/feedparser-rs-core/src/namespace/dublin_core.rs

@@ -32,10 +32,8 @@ pub const DC_NAMESPACE: &str = "http://purl.org/dc/elements/1.1/";
 pub fn handle_feed_element(element: &str, text: &str, feed: &mut FeedMeta) {
     match element {
         "creator" => {
-            // dc:creator → author (if not already set)
-            if feed.author.is_none() {
-                feed.author = Some(text.into());
-            }
+            // dc:creator → author (always overrides)
+            feed.author = Some(text.into());
             // Store in dc_creator field
             feed.dc_creator = Some(text.into());
             // Also add to authors list
@@ -47,6 +45,7 @@ pub fn handle_feed_element(element: &str, text: &str, feed: &mut FeedMeta) {
                 && feed.updated.is_none()
             {
                 feed.updated = Some(dt);
+                feed.updated_str = Some(text.to_string());
             }
         }
         "subject" => {
@@ -111,18 +110,16 @@ pub fn handle_feed_element(element: &str, text: &str, feed: &mut FeedMeta) {
 pub fn handle_entry_element(element: &str, text: &str, entry: &mut Entry) {
     match element {
         "creator" => {
-            if entry.author.is_none() {
-                entry.author = Some(text.into());
-            }
+            // dc:creator takes precedence over <author>; reconciled at </item>
             entry.dc_creator = Some(text.into());
             entry.authors.push(Person::from_name(text));
         }
         "date" => {
             if let Some(dt) = parse_date(text) {
                 entry.dc_date = Some(dt);
-                // Prefer published over updated for entries
-                if entry.published.is_none() {
-                    entry.published = Some(dt);
+                if entry.updated.is_none() {
+                    entry.updated = Some(dt);
+                    entry.updated_str = Some(text.to_string());
                 }
             }
         }
@@ -149,6 +146,9 @@ pub fn handle_entry_element(element: &str, text: &str, entry: &mut Entry) {
             entry.contributors.push(Person::from_name(text));
         }
         "rights" => {
+            if entry.rights.is_none() {
+                entry.rights = Some(text.to_string());
+            }
             entry.dc_rights = Some(text.to_string());
         }
         _ => {
@@ -177,8 +177,8 @@ mod tests {
         handle_feed_element("creator", "Alice", &mut feed);
         handle_feed_element("creator", "Bob", &mut feed);
 
-        // First creator becomes primary author
-        assert_eq!(feed.author.as_deref(), Some("Alice"));
+        // Last dc:creator wins (always overrides)
+        assert_eq!(feed.author.as_deref(), Some("Bob"));
         // Both are in authors list
         assert_eq!(feed.authors.len(), 2);
     }
@@ -232,16 +232,40 @@ mod tests {
         handle_entry_element("subject", "Tech", &mut entry);
         handle_entry_element("description", "Entry summary", &mut entry);
 
-        assert_eq!(entry.author.as_deref(), Some("Jane Doe"));
+        // dc:creator is stored in dc_creator; entry.author is reconciled at </item> in rss.rs
+        assert_eq!(entry.dc_creator.as_deref(), Some("Jane Doe"));
         assert_eq!(entry.tags.len(), 1);
         assert_eq!(entry.summary.as_deref(), Some("Entry summary"));
     }
 
     #[test]
-    fn test_entry_published_from_dc_date() {
+    fn test_entry_updated_from_dc_date() {
         let mut entry = Entry::default();
         handle_entry_element("date", "2024-01-15T10:30:00Z", &mut entry);
 
-        assert!(entry.published.is_some());
+        assert!(entry.updated.is_some());
+        assert!(entry.published.is_none());
+    }
+
+    #[test]
+    fn test_entry_dc_rights_sets_both_fields() {
+        let mut entry = Entry::default();
+        handle_entry_element("rights", "Copyright 2024 Example", &mut entry);
+
+        assert_eq!(entry.rights.as_deref(), Some("Copyright 2024 Example"));
+        assert_eq!(entry.dc_rights.as_deref(), Some("Copyright 2024 Example"));
+    }
+
+    #[test]
+    fn test_entry_dc_rights_does_not_overwrite_rights() {
+        let mut entry = Entry {
+            rights: Some("Atom rights".to_string()),
+            ..Default::default()
+        };
+        handle_entry_element("rights", "DC rights", &mut entry);
+
+        // dc:rights should not overwrite rights already set (e.g. by Atom <rights>)
+        assert_eq!(entry.rights.as_deref(), Some("Atom rights"));
+        assert_eq!(entry.dc_rights.as_deref(), Some("DC rights"));
     }
 }

{feedparser_rs-0.4.7 → feedparser_rs-0.5.0}/crates/feedparser-rs-core/src/namespace/georss.rs

@@ -178,25 +178,25 @@ pub fn handle_entry_element(
     match tag {
         b"point" => {
             if let Some(loc) = parse_point(text) {
-                entry.geo = Some(Box::new(loc));
+                entry.r#where = Some(Box::new(loc));
             }
             true
         }
         b"line" => {
             if let Some(loc) = parse_line(text) {
-                entry.geo = Some(Box::new(loc));
+                entry.r#where = Some(Box::new(loc));
             }
             true
         }
         b"polygon" => {
             if let Some(loc) = parse_polygon(text) {
-                entry.geo = Some(Box::new(loc));
+                entry.r#where = Some(Box::new(loc));
             }
             true
         }
         b"box" => {
             if let Some(loc) = parse_box(text) {
-                entry.geo = Some(Box::new(loc));
+                entry.r#where = Some(Box::new(loc));
             }
             true
         }
@@ -225,25 +225,25 @@ pub fn handle_feed_element(
     match tag {
         b"point" => {
             if let Some(loc) = parse_point(text) {
-                feed.geo = Some(Box::new(loc));
+                feed.r#where = Some(Box::new(loc));
             }
             true
         }
         b"line" => {
             if let Some(loc) = parse_line(text) {
-                feed.geo = Some(Box::new(loc));
+                feed.r#where = Some(Box::new(loc));
             }
             true
         }
         b"polygon" => {
             if let Some(loc) = parse_polygon(text) {
-                feed.geo = Some(Box::new(loc));
+                feed.r#where = Some(Box::new(loc));
             }
             true
         }
         b"box" => {
             if let Some(loc) = parse_box(text) {
-                feed.geo = Some(Box::new(loc));
+                feed.r#where = Some(Box::new(loc));
             }
             true
         }
@@ -426,9 +426,9 @@ mod tests {
 
         let handled = handle_entry_element(b"point", "45.256 -71.92", &mut entry, &limits);
         assert!(handled);
-        assert!(entry.geo.is_some());
+        assert!(entry.r#where.is_some());
 
-        let geo = entry.geo.as_ref().unwrap();
+        let geo = entry.r#where.as_ref().unwrap();
         assert_eq!(geo.geo_type, GeoType::Point);
         assert_eq!(geo.coordinates[0], (45.256, -71.92));
     }
@@ -441,8 +441,8 @@ mod tests {
         let handled =
             handle_entry_element(b"line", "45.256 -71.92 46.0 -72.0", &mut entry, &limits);
         assert!(handled);
-        assert!(entry.geo.is_some());
-        assert_eq!(entry.geo.as_ref().unwrap().geo_type, GeoType::Line);
+        assert!(entry.r#where.is_some());
+        assert_eq!(entry.r#where.as_ref().unwrap().geo_type, GeoType::Line);
     }
 
     #[test]
@@ -452,7 +452,7 @@ mod tests {
 
         let handled = handle_entry_element(b"unknown", "data", &mut entry, &limits);
         assert!(!handled);
-        assert!(entry.geo.is_none());
+        assert!(entry.r#where.is_none());
     }
 
     #[test]
@@ -487,9 +487,9 @@ mod tests {
 
         let handled = handle_feed_element(b"point", "45.256 -71.92", &mut feed, &limits);
         assert!(handled);
-        assert!(feed.geo.is_some());
+        assert!(feed.r#where.is_some());
 
-        let geo = feed.geo.as_ref().unwrap();
+        let geo = feed.r#where.as_ref().unwrap();
         assert_eq!(geo.geo_type, GeoType::Point);
         assert_eq!(geo.coordinates[0], (45.256, -71.92));
     }
@@ -501,8 +501,8 @@ mod tests {
 
         let handled = handle_feed_element(b"line", "45.256 -71.92 46.0 -72.0", &mut feed, &limits);
         assert!(handled);
-        assert!(feed.geo.is_some());
-        assert_eq!(feed.geo.as_ref().unwrap().geo_type, GeoType::Line);
+        assert!(feed.r#where.is_some());
+        assert_eq!(feed.r#where.as_ref().unwrap().geo_type, GeoType::Line);
     }
 
     #[test]
@@ -517,8 +517,8 @@ mod tests {
             &limits,
         );
         assert!(handled);
-        assert!(feed.geo.is_some());
-        assert_eq!(feed.geo.as_ref().unwrap().geo_type, GeoType::Polygon);
+        assert!(feed.r#where.is_some());
+        assert_eq!(feed.r#where.as_ref().unwrap().geo_type, GeoType::Polygon);
     }
 
     #[test]
@@ -528,8 +528,8 @@ mod tests {
 
         let handled = handle_feed_element(b"box", "45.0 -72.0 46.0 -71.0", &mut feed, &limits);
         assert!(handled);
-        assert!(feed.geo.is_some());
-        assert_eq!(feed.geo.as_ref().unwrap().geo_type, GeoType::Box);
+        assert!(feed.r#where.is_some());
+        assert_eq!(feed.r#where.as_ref().unwrap().geo_type, GeoType::Box);
     }
 
     #[test]
@@ -539,7 +539,7 @@ mod tests {
 
         let handled = handle_feed_element(b"unknown", "data", &mut feed, &limits);
         assert!(!handled);
-        assert!(feed.geo.is_none());
+        assert!(feed.r#where.is_none());
     }
 
     #[test]
@@ -549,6 +549,6 @@ mod tests {
 
         let handled = handle_feed_element(b"point", "invalid data", &mut feed, &limits);
         assert!(handled);
-        assert!(feed.geo.is_none());
+        assert!(feed.r#where.is_none());
     }
 }

{feedparser_rs-0.4.7 → feedparser_rs-0.5.0}/crates/feedparser-rs-core/src/namespace/media_rss.rs

@@ -198,13 +198,13 @@ pub fn handle_entry_element(element: &str, text: &str, entry: &mut Entry) {
 /// let enclosure = media_content_to_enclosure(&content);
 /// assert_eq!(enclosure.url, "https://example.com/video.mp4");
 /// assert_eq!(enclosure.enclosure_type.as_deref(), Some("video/mp4"));
-/// assert_eq!(enclosure.length, Some(1_024_000));
+/// assert_eq!(enclosure.length.as_deref(), Some("1024000"));
 /// ```
 pub fn media_content_to_enclosure(content: &MediaContent) -> Enclosure {
     Enclosure {
         url: content.url.clone().into(),
         enclosure_type: content.type_.as_ref().map(|t| t.clone().into()),
-        length: content.file_size,
+        length: content.file_size.map(|v| v.to_string()),
     }
 }
 
@@ -412,7 +412,7 @@ mod tests {
 
         assert_eq!(enclosure.url, "https://example.com/video.mp4");
         assert_eq!(enclosure.enclosure_type.as_deref(), Some("video/mp4"));
-        assert_eq!(enclosure.length, Some(1_024_000));
+        assert_eq!(enclosure.length.as_deref(), Some("1024000"));
     }
 
     #[test]

{feedparser_rs-0.4.7 → feedparser_rs-0.5.0}/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.5.0/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);
+    }
+}