feedparser-rs 0.5.1__tar.gz → 0.5.2__tar.gz

{feedparser_rs-0.5.1 → feedparser_rs-0.5.2}/Cargo.lock

@@ -500,9 +500,9 @@ dependencies = [
 
 [[package]]
 name = "ctor"
-version = "0.6.3"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "424e0138278faeb2b401f174ad17e715c829512d74f3d1e81eb43365c2e0590e"
+checksum = "352d39c2f7bef1d6ad73db6f5160efcaed66d94ef8c6c573a8410c00bf909a98"
 dependencies = [
  "ctor-proc-macro",
  "dtor",
@@ -558,9 +558,9 @@ dependencies = [
 
 [[package]]
 name = "dtor"
-version = "0.1.1"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "404d02eeb088a82cfd873006cb713fe411306c7d182c344905e101fb1167d301"
+checksum = "f1057d6c64987086ff8ed0fd3fbf377a6b7d205cc7715868cd401705f715cbe4"
 dependencies = [
  "dtor-proc-macro",
 ]
@@ -600,7 +600,7 @@ checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
 
 [[package]]
 name = "feedparser-rs"
-version = "0.5.1"
+version = "0.5.2"
 dependencies = [
  "ammonia",
  "chrono",
@@ -623,7 +623,7 @@ dependencies = [
 
 [[package]]
 name = "feedparser-rs-node"
-version = "0.5.1"
+version = "0.5.2"
 dependencies = [
  "feedparser-rs",
  "napi",
@@ -633,7 +633,7 @@ dependencies = [
 
 [[package]]
 name = "feedparser-rs-py"
-version = "0.5.1"
+version = "0.5.2"
 dependencies = [
  "chrono",
  "feedparser-rs",
@@ -1330,9 +1330,9 @@ dependencies = [
 
 [[package]]
 name = "napi"
-version = "3.8.3"
+version = "3.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6944d0bf100571cd6e1a98a316cdca262deb6fccf8d93f5ae1502ca3fc88bd3"
+checksum = "fb7848c221fb7bb789e02f01875287ebb1e078b92a6566a34de01ef8806e7c2b"
 dependencies = [
  "anyhow",
  "bitflags",
@@ -1352,9 +1352,9 @@ checksum = "d376940fd5b723c6893cd1ee3f33abbfd86acb1cd1ec079f3ab04a2a3bc4d3b1"
 
 [[package]]
 name = "napi-derive"
-version = "3.5.2"
+version = "3.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c914b5e420182bfb73504e0607592cdb8e2e21437d450883077669fb72a114d"
+checksum = "60867ff9a6f76e82350e0c3420cb0736f5866091b61d7d8a024baa54b0ec17dd"
 dependencies = [
  "convert_case",
  "ctor",

{feedparser_rs-0.5.1 → feedparser_rs-0.5.2}/Cargo.toml

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

{feedparser_rs-0.5.1 → feedparser_rs-0.5.2}/PKG-INFO

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

{feedparser_rs-0.5.1 → feedparser_rs-0.5.2}/crates/feedparser-rs-core/src/limits.rs

@@ -143,6 +143,36 @@ pub struct ParserLimits {
     ///
     /// Default: 20 recipients
     pub max_value_recipients: usize,
+
+    /// Maximum number of alternate enclosures per entry
+    ///
+    /// Default: 20
+    pub max_podcast_alternate_enclosures: usize,
+
+    /// Maximum number of sources per alternate enclosure
+    ///
+    /// Default: 10
+    pub max_podcast_alternate_enclosure_sources: usize,
+
+    /// Maximum number of podroll entries per feed
+    ///
+    /// Default: 50
+    pub max_podcast_podroll: usize,
+
+    /// Maximum number of socialInteract elements per entry
+    ///
+    /// Default: 20
+    pub max_podcast_social_interact: usize,
+
+    /// Maximum number of txt records per feed or entry
+    ///
+    /// Default: 20
+    pub max_podcast_txt: usize,
+
+    /// Maximum number of follow links per feed or entry
+    ///
+    /// Default: 20
+    pub max_podcast_follow: usize,
 }
 
 impl Default for ParserLimits {
@@ -170,6 +200,12 @@ impl Default for ParserLimits {
             max_podcast_funding: 20,
             max_podcast_persons: 50,
             max_value_recipients: 20,
+            max_podcast_alternate_enclosures: 20,
+            max_podcast_alternate_enclosure_sources: 10,
+            max_podcast_podroll: 50,
+            max_podcast_social_interact: 20,
+            max_podcast_txt: 20,
+            max_podcast_follow: 20,
         }
     }
 }
@@ -209,6 +245,12 @@ impl ParserLimits {
             max_podcast_funding: 5,
             max_podcast_persons: 10,
             max_value_recipients: 5,
+            max_podcast_alternate_enclosures: 5,
+            max_podcast_alternate_enclosure_sources: 3,
+            max_podcast_podroll: 10,
+            max_podcast_social_interact: 5,
+            max_podcast_txt: 5,
+            max_podcast_follow: 5,
         }
     }
 
@@ -246,6 +288,12 @@ impl ParserLimits {
             max_podcast_funding: 50,
             max_podcast_persons: 200,
             max_value_recipients: 50,
+            max_podcast_alternate_enclosures: 100,
+            max_podcast_alternate_enclosure_sources: 50,
+            max_podcast_podroll: 200,
+            max_podcast_social_interact: 100,
+            max_podcast_txt: 100,
+            max_podcast_follow: 100,
         }
     }
 

{feedparser_rs-0.5.1 → feedparser_rs-0.5.2}/crates/feedparser-rs-core/src/namespace/dublin_core.rs

@@ -40,8 +40,12 @@ pub fn handle_feed_element(element: &str, text: &str, feed: &mut FeedMeta) {
             feed.authors.push(Person::from_name(text));
         }
         "date" => {
-            // dc:date → updated (always overrides pubDate promotion)
             if let Some(dt) = parse_date(text) {
+                if feed.published.is_none() {
+                    feed.published = Some(dt);
+                    feed.published_str = Some(text.to_string());
+                }
+                // dc:date → updated (always overrides pubDate promotion)
                 feed.updated = Some(dt);
                 feed.updated_str = Some(text.to_string());
             }
@@ -115,6 +119,10 @@ pub fn handle_entry_element(element: &str, text: &str, entry: &mut Entry) {
         "date" => {
             if let Some(dt) = parse_date(text) {
                 entry.dc_date = Some(dt);
+                if entry.published.is_none() {
+                    entry.published = Some(dt);
+                    entry.published_str = Some(text.to_string());
+                }
                 // dc:date is more authoritative than pubDate for updated; always override
                 entry.updated = Some(dt);
                 entry.updated_str = Some(text.to_string());
@@ -236,12 +244,12 @@ mod tests {
     }
 
     #[test]
-    fn test_entry_updated_from_dc_date() {
+    fn test_entry_updated_and_published_from_dc_date() {
         let mut entry = Entry::default();
         handle_entry_element("date", "2024-01-15T10:30:00Z", &mut entry);
 
         assert!(entry.updated.is_some());
-        assert!(entry.published.is_none());
+        assert!(entry.published.is_some());
     }
 
     #[test]

{feedparser_rs-0.5.1 → feedparser_rs-0.5.2}/crates/feedparser-rs-core/src/namespace/georss.rs

@@ -51,6 +51,14 @@ pub struct GeoLocation {
     ///
     /// Default is WGS84 (latitude/longitude) if not specified
     pub srs_name: Option<String>,
+    /// Elevation in meters (from `georss:elev`)
+    pub elev: Option<f64>,
+    /// Feature type classification (from `georss:featuretypetag`)
+    pub feature_type_tag: Option<String>,
+    /// Human-readable place name (from `georss:featurename`)
+    pub feature_name: Option<String>,
+    /// Relationship type (from `georss:relationshiptag`)
+    pub relationship_tag: Option<String>,
 }
 
 impl GeoLocation {
@@ -74,7 +82,7 @@ impl GeoLocation {
         Self {
             geo_type: GeoType::Point,
             coordinates: vec![(lat, lon)],
-            srs_name: None,
+            ..Default::default()
         }
     }
 
@@ -94,11 +102,11 @@ impl GeoLocation {
     /// assert_eq!(loc.coordinates.len(), 2);
     /// ```
     #[must_use]
-    pub const fn line(coords: Vec<(f64, f64)>) -> Self {
+    pub fn line(coords: Vec<(f64, f64)>) -> Self {
         Self {
             geo_type: GeoType::Line,
             coordinates: coords,
-            srs_name: None,
+            ..Default::default()
         }
     }
 
@@ -122,11 +130,11 @@ impl GeoLocation {
     /// let loc = GeoLocation::polygon(coords);
     /// ```
     #[must_use]
-    pub const fn polygon(coords: Vec<(f64, f64)>) -> Self {
+    pub fn polygon(coords: Vec<(f64, f64)>) -> Self {
         Self {
             geo_type: GeoType::Polygon,
             coordinates: coords,
-            srs_name: None,
+            ..Default::default()
         }
     }
 
@@ -152,7 +160,7 @@ impl GeoLocation {
         Self {
             geo_type: GeoType::Box,
             coordinates: vec![(lower_lat, lower_lon), (upper_lat, upper_lon)],
-            srs_name: None,
+            ..Default::default()
         }
     }
 }
@@ -258,28 +266,80 @@ pub fn handle_entry_element(
     match tag {
         b"point" => {
             if let Some(loc) = parse_point(text) {
-                entry.r#where = Some(Box::new(loc));
+                let existing = entry
+                    .r#where
+                    .get_or_insert_with(|| Box::new(GeoLocation::default()));
+                existing.geo_type = loc.geo_type;
+                existing.coordinates = loc.coordinates;
+                existing.srs_name = loc.srs_name;
             }
             true
         }
         b"line" => {
             if let Some(loc) = parse_line(text) {
-                entry.r#where = Some(Box::new(loc));
+                let existing = entry
+                    .r#where
+                    .get_or_insert_with(|| Box::new(GeoLocation::default()));
+                existing.geo_type = loc.geo_type;
+                existing.coordinates = loc.coordinates;
+                existing.srs_name = loc.srs_name;
             }
             true
         }
         b"polygon" => {
             if let Some(loc) = parse_polygon(text) {
-                entry.r#where = Some(Box::new(loc));
+                let existing = entry
+                    .r#where
+                    .get_or_insert_with(|| Box::new(GeoLocation::default()));
+                existing.geo_type = loc.geo_type;
+                existing.coordinates = loc.coordinates;
+                existing.srs_name = loc.srs_name;
             }
             true
         }
         b"box" => {
             if let Some(loc) = parse_box(text) {
-                entry.r#where = Some(Box::new(loc));
+                let existing = entry
+                    .r#where
+                    .get_or_insert_with(|| Box::new(GeoLocation::default()));
+                existing.geo_type = loc.geo_type;
+                existing.coordinates = loc.coordinates;
+                existing.srs_name = loc.srs_name;
             }
             true
         }
+        b"elev" => {
+            if let Ok(v) = text.trim().parse::<f64>()
+                && v.is_finite()
+            {
+                entry
+                    .r#where
+                    .get_or_insert_with(|| Box::new(GeoLocation::default()))
+                    .elev = Some(v);
+            }
+            true
+        }
+        b"featuretypetag" => {
+            entry
+                .r#where
+                .get_or_insert_with(|| Box::new(GeoLocation::default()))
+                .feature_type_tag = Some(text.to_string());
+            true
+        }
+        b"featurename" => {
+            entry
+                .r#where
+                .get_or_insert_with(|| Box::new(GeoLocation::default()))
+                .feature_name = Some(text.to_string());
+            true
+        }
+        b"relationshiptag" => {
+            entry
+                .r#where
+                .get_or_insert_with(|| Box::new(GeoLocation::default()))
+                .relationship_tag = Some(text.to_string());
+            true
+        }
         _ => false,
     }
 }
@@ -305,28 +365,76 @@ pub fn handle_feed_element(
     match tag {
         b"point" => {
             if let Some(loc) = parse_point(text) {
-                feed.r#where = Some(Box::new(loc));
+                let existing = feed
+                    .r#where
+                    .get_or_insert_with(|| Box::new(GeoLocation::default()));
+                existing.geo_type = loc.geo_type;
+                existing.coordinates = loc.coordinates;
+                existing.srs_name = loc.srs_name;
             }
             true
         }
         b"line" => {
             if let Some(loc) = parse_line(text) {
-                feed.r#where = Some(Box::new(loc));
+                let existing = feed
+                    .r#where
+                    .get_or_insert_with(|| Box::new(GeoLocation::default()));
+                existing.geo_type = loc.geo_type;
+                existing.coordinates = loc.coordinates;
+                existing.srs_name = loc.srs_name;
             }
             true
         }
         b"polygon" => {
             if let Some(loc) = parse_polygon(text) {
-                feed.r#where = Some(Box::new(loc));
+                let existing = feed
+                    .r#where
+                    .get_or_insert_with(|| Box::new(GeoLocation::default()));
+                existing.geo_type = loc.geo_type;
+                existing.coordinates = loc.coordinates;
+                existing.srs_name = loc.srs_name;
             }
             true
         }
         b"box" => {
             if let Some(loc) = parse_box(text) {
-                feed.r#where = Some(Box::new(loc));
+                let existing = feed
+                    .r#where
+                    .get_or_insert_with(|| Box::new(GeoLocation::default()));
+                existing.geo_type = loc.geo_type;
+                existing.coordinates = loc.coordinates;
+                existing.srs_name = loc.srs_name;
+            }
+            true
+        }
+        b"elev" => {
+            if let Ok(v) = text.trim().parse::<f64>()
+                && v.is_finite()
+            {
+                feed.r#where
+                    .get_or_insert_with(|| Box::new(GeoLocation::default()))
+                    .elev = Some(v);
             }
             true
         }
+        b"featuretypetag" => {
+            feed.r#where
+                .get_or_insert_with(|| Box::new(GeoLocation::default()))
+                .feature_type_tag = Some(text.to_string());
+            true
+        }
+        b"featurename" => {
+            feed.r#where
+                .get_or_insert_with(|| Box::new(GeoLocation::default()))
+                .feature_name = Some(text.to_string());
+            true
+        }
+        b"relationshiptag" => {
+            feed.r#where
+                .get_or_insert_with(|| Box::new(GeoLocation::default()))
+                .relationship_tag = Some(text.to_string());
+            true
+        }
         _ => false,
     }
 }
@@ -341,7 +449,7 @@ fn parse_point(text: &str) -> Option<GeoLocation> {
         Some(GeoLocation {
             geo_type: GeoType::Point,
             coordinates: coords,
-            srs_name: None,
+            ..Default::default()
         })
     } else {
         None
@@ -358,7 +466,7 @@ fn parse_line(text: &str) -> Option<GeoLocation> {
         Some(GeoLocation {
             geo_type: GeoType::Line,
             coordinates: coords,
-            srs_name: None,
+            ..Default::default()
         })
     } else {
         None
@@ -375,7 +483,7 @@ fn parse_polygon(text: &str) -> Option<GeoLocation> {
         Some(GeoLocation {
             geo_type: GeoType::Polygon,
             coordinates: coords,
-            srs_name: None,
+            ..Default::default()
         })
     } else {
         None
@@ -392,7 +500,7 @@ fn parse_box(text: &str) -> Option<GeoLocation> {
         Some(GeoLocation {
             geo_type: GeoType::Box,
             coordinates: coords,
-            srs_name: None,
+            ..Default::default()
         })
     } else {
         None
@@ -631,4 +739,118 @@ mod tests {
         assert!(handled);
         assert!(feed.r#where.is_none());
     }
+
+    #[test]
+    fn test_handle_entry_element_elev() {
+        let mut entry = Entry::default();
+        let limits = ParserLimits::default();
+
+        let handled = handle_entry_element(b"elev", "1337.5", &mut entry, &limits);
+        assert!(handled);
+        let geo = entry.r#where.as_ref().unwrap();
+        assert_eq!(geo.elev, Some(1337.5));
+    }
+
+    #[test]
+    fn test_handle_entry_element_feature_name() {
+        let mut entry = Entry::default();
+        let limits = ParserLimits::default();
+
+        let handled = handle_entry_element(b"featurename", "Mont Mégantic", &mut entry, &limits);
+        assert!(handled);
+        let geo = entry.r#where.as_ref().unwrap();
+        assert_eq!(geo.feature_name.as_deref(), Some("Mont Mégantic"));
+    }
+
+    #[test]
+    fn test_handle_entry_element_feature_type_tag() {
+        let mut entry = Entry::default();
+        let limits = ParserLimits::default();
+
+        let handled = handle_entry_element(b"featuretypetag", "mountain", &mut entry, &limits);
+        assert!(handled);
+        let geo = entry.r#where.as_ref().unwrap();
+        assert_eq!(geo.feature_type_tag.as_deref(), Some("mountain"));
+    }
+
+    #[test]
+    fn test_handle_entry_element_relationship_tag() {
+        let mut entry = Entry::default();
+        let limits = ParserLimits::default();
+
+        let handled =
+            handle_entry_element(b"relationshiptag", "is-located-at", &mut entry, &limits);
+        assert!(handled);
+        let geo = entry.r#where.as_ref().unwrap();
+        assert_eq!(geo.relationship_tag.as_deref(), Some("is-located-at"));
+    }
+
+    #[test]
+    fn test_extended_attrs_without_geometry() {
+        let mut entry = Entry::default();
+        let limits = ParserLimits::default();
+
+        handle_entry_element(b"featurename", "Unknown Location", &mut entry, &limits);
+        let geo = entry.r#where.as_ref().unwrap();
+        assert_eq!(geo.feature_name.as_deref(), Some("Unknown Location"));
+        assert!(geo.coordinates.is_empty());
+    }
+
+    #[test]
+    fn test_extended_attrs_invalid_elev() {
+        let mut entry = Entry::default();
+        let limits = ParserLimits::default();
+
+        let handled = handle_entry_element(b"elev", "not-a-number", &mut entry, &limits);
+        assert!(handled);
+        // GeoLocation not created because elev parse failed
+        assert!(entry.r#where.is_none());
+    }
+
+    #[test]
+    fn test_extended_attrs_elev_non_finite_ignored() {
+        let limits = ParserLimits::default();
+
+        for value in ["NaN", "Infinity", "-Infinity"] {
+            let mut entry = Entry::default();
+            let handled = handle_entry_element(b"elev", value, &mut entry, &limits);
+            assert!(handled, "element must be recognized for value {value}");
+            assert!(
+                entry.r#where.is_none(),
+                "non-finite elev '{value}' must not create GeoLocation"
+            );
+        }
+    }
+
+    #[test]
+    fn test_extended_attrs_before_geometry() {
+        let mut entry = Entry::default();
+        let limits = ParserLimits::default();
+
+        handle_entry_element(b"featurename", "Reverse Order", &mut entry, &limits);
+        handle_entry_element(b"elev", "500.0", &mut entry, &limits);
+        handle_entry_element(b"point", "40.0 -74.0", &mut entry, &limits);
+
+        let geo = entry.r#where.as_ref().unwrap();
+        assert_eq!(geo.geo_type, GeoType::Point);
+        assert_eq!(geo.coordinates[0], (40.0, -74.0));
+        assert_eq!(geo.feature_name.as_deref(), Some("Reverse Order"));
+        assert_eq!(geo.elev, Some(500.0));
+    }
+
+    #[test]
+    fn test_extended_attrs_after_geometry() {
+        let mut entry = Entry::default();
+        let limits = ParserLimits::default();
+
+        handle_entry_element(b"point", "45.256 -71.92", &mut entry, &limits);
+        handle_entry_element(b"featurename", "Mont Mégantic", &mut entry, &limits);
+        handle_entry_element(b"elev", "1337.5", &mut entry, &limits);
+
+        let geo = entry.r#where.as_ref().unwrap();
+        assert_eq!(geo.geo_type, GeoType::Point);
+        assert_eq!(geo.coordinates[0], (45.256, -71.92));
+        assert_eq!(geo.feature_name.as_deref(), Some("Mont Mégantic"));
+        assert_eq!(geo.elev, Some(1337.5));
+    }
 }