feat(bindings): add syndication and Dublin Core support to Python and Node.js bindings

Add complete support for syndication module (RSS 1.0) and Dublin Core metadata
fields in both Python (PyO3) and Node.js (napi-rs) bindings.

Changes:
- Export SyndicationMeta and UpdatePeriod from core library
- Python bindings:
  - New PySyndicationMeta wrapper class with update_period, update_frequency, update_base getters
  - Added syndication, dc_creator, dc_publisher, dc_rights getters to PyFeedMeta
  - Added comprehensive test suite for syndication and Dublin Core fields
- Node.js bindings:
  - New SyndicationMeta struct with automatic camelCase conversion (updatePeriod, etc.)
  - Added syndication, dcCreator, dcPublisher, dcRights fields to FeedMeta
  - Added test suite for syndication and Dublin Core fields
- All tests passing
- Clippy clean with no warnings

This completes Phase 3 syndication bindings implementation.

Author: bug-ops

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

@@ -72,6 +72,8 @@ pub use types::{
     TextType, parse_duration, parse_explicit,
 };
 
+pub use namespace::syndication::{SyndicationMeta, UpdatePeriod};
+
 #[cfg(feature = "http")]
 pub use http::{FeedHttpClient, FeedHttpResponse};
 

crates/feedparser-rs-node/__test__/syndication.spec.mjs

@@ -0,0 +1,94 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { parse } from '../index.js';
+
+describe('syndication', () => {
+  it('should parse syndication updatePeriod', () => {
+    const xml = `<?xml version="1.0"?>
+      <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+               xmlns="http://purl.org/rss/1.0/"
+               xmlns:syn="http://purl.org/rss/1.0/modules/syndication/">
+        <channel>
+          <title>Test Feed</title>
+          <link>https://example.com</link>
+          <syn:updatePeriod>daily</syn:updatePeriod>
+        </channel>
+      </rdf:RDF>`;
+
+    const feed = parse(xml);
+    assert.ok(feed.feed.syndication);
+    assert.strictEqual(feed.feed.syndication.updatePeriod, 'daily');
+  });
+
+  it('should parse syndication updateFrequency', () => {
+    const xml = `<?xml version="1.0"?>
+      <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+               xmlns="http://purl.org/rss/1.0/"
+               xmlns:syn="http://purl.org/rss/1.0/modules/syndication/">
+        <channel>
+          <title>Test Feed</title>
+          <link>https://example.com</link>
+          <syn:updateFrequency>2</syn:updateFrequency>
+        </channel>
+      </rdf:RDF>`;
+
+    const feed = parse(xml);
+    assert.ok(feed.feed.syndication);
+    assert.strictEqual(feed.feed.syndication.updateFrequency, 2);
+  });
+
+  it('should parse complete syndication metadata', () => {
+    const xml = `<?xml version="1.0"?>
+      <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+               xmlns="http://purl.org/rss/1.0/"
+               xmlns:syn="http://purl.org/rss/1.0/modules/syndication/">
+        <channel>
+          <title>Test Feed</title>
+          <link>https://example.com</link>
+          <syn:updatePeriod>hourly</syn:updatePeriod>
+          <syn:updateFrequency>1</syn:updateFrequency>
+          <syn:updateBase>2024-01-01T00:00:00Z</syn:updateBase>
+        </channel>
+      </rdf:RDF>`;
+
+    const feed = parse(xml);
+    const syn = feed.feed.syndication;
+    assert.ok(syn);
+    assert.strictEqual(syn.updatePeriod, 'hourly');
+    assert.strictEqual(syn.updateFrequency, 1);
+    assert.strictEqual(syn.updateBase, '2024-01-01T00:00:00Z');
+  });
+
+  it('should return undefined when syndication data is missing', () => {
+    const xml = `<?xml version="1.0"?>
+      <rss version="2.0">
+        <channel>
+          <title>Test Feed</title>
+          <link>https://example.com</link>
+        </channel>
+      </rss>`;
+
+    const feed = parse(xml);
+    assert.strictEqual(feed.feed.syndication, undefined);
+  });
+
+  it('should parse Dublin Core fields', () => {
+    const xml = `<?xml version="1.0"?>
+      <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+               xmlns="http://purl.org/rss/1.0/"
+               xmlns:dc="http://purl.org/dc/elements/1.1/">
+        <channel rdf:about="https://example.com">
+          <title>Test Feed</title>
+          <link>https://example.com</link>
+          <dc:creator>John Doe</dc:creator>
+          <dc:publisher>ACME Corp</dc:publisher>
+          <dc:rights>Copyright 2024</dc:rights>
+        </channel>
+      </rdf:RDF>`;
+
+    const feed = parse(xml);
+    assert.strictEqual(feed.feed.dcCreator, 'John Doe');
+    assert.strictEqual(feed.feed.dcPublisher, 'ACME Corp');
+    assert.strictEqual(feed.feed.dcRights, 'Copyright 2024');
+  });
+});

crates/feedparser-rs-node/index.d.ts

@@ -143,6 +143,14 @@ export interface FeedMeta {
   ttl?: number
   /** License URL (Creative Commons, etc.) */
   license?: string
+  /** Syndication module metadata (RSS 1.0) */
+  syndication?: SyndicationMeta
+  /** Dublin Core creator (author fallback) */
+  dcCreator?: string
+  /** Dublin Core publisher */
+  dcPublisher?: string
+  /** Dublin Core rights (copyright) */
+  dcRights?: string
 }
 
 /** Generator metadata */
@@ -369,6 +377,16 @@ export interface Source {
   id?: string
 }
 
+/** Syndication module metadata (RSS 1.0) */
+export interface SyndicationMeta {
+  /** Update period (hourly, daily, weekly, monthly, yearly) */
+  updatePeriod?: string
+  /** Number of times updated per period */
+  updateFrequency?: number
+  /** Base date for update schedule (ISO 8601) */
+  updateBase?: string
+}
+
 /** Tag/category */
 export interface Tag {
   /** Tag term/label */

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

@@ -9,7 +9,8 @@ use feedparser_rs::{
     FeedMeta as CoreFeedMeta, Generator as CoreGenerator, Image as CoreImage, Link as CoreLink,
     ParsedFeed as CoreParsedFeed, ParserLimits, Person as CorePerson,
     PodcastPerson as CorePodcastPerson, PodcastTranscript as CorePodcastTranscript,
-    Source as CoreSource, Tag as CoreTag, TextConstruct as CoreTextConstruct, TextType,
+    Source as CoreSource, SyndicationMeta as CoreSyndicationMeta, Tag as CoreTag,
+    TextConstruct as CoreTextConstruct, TextType,
 };
 
 /// Default maximum feed size (100 MB) - prevents DoS attacks
@@ -264,6 +265,27 @@ impl From<CoreParsedFeed> for ParsedFeed {
     }
 }
 
+/// Syndication module metadata (RSS 1.0)
+#[napi(object)]
+pub struct SyndicationMeta {
+    /// Update period (hourly, daily, weekly, monthly, yearly)
+    pub update_period: Option<String>,
+    /// Number of times updated per period
+    pub update_frequency: Option<u32>,
+    /// Base date for update schedule (ISO 8601)
+    pub update_base: Option<String>,
+}
+
+impl From<CoreSyndicationMeta> for SyndicationMeta {
+    fn from(core: CoreSyndicationMeta) -> Self {
+        Self {
+            update_period: core.update_period.map(|p| p.as_str().to_string()),
+            update_frequency: core.update_frequency,
+            update_base: core.update_base,
+        }
+    }
+}
+
 /// Feed metadata
 #[napi(object)]
 pub struct FeedMeta {
@@ -319,6 +341,14 @@ pub struct FeedMeta {
     pub ttl: Option<u32>,
     /// License URL (Creative Commons, etc.)
     pub license: Option<String>,
+    /// Syndication module metadata (RSS 1.0)
+    pub syndication: Option<SyndicationMeta>,
+    /// Dublin Core creator (author fallback)
+    pub dc_creator: Option<String>,
+    /// Dublin Core publisher
+    pub dc_publisher: Option<String>,
+    /// Dublin Core rights (copyright)
+    pub dc_rights: Option<String>,
 }
 
 impl From<CoreFeedMeta> for FeedMeta {
@@ -350,6 +380,10 @@ impl From<CoreFeedMeta> for FeedMeta {
             id: core.id,
             ttl: core.ttl,
             license: core.license,
+            syndication: core.syndication.map(SyndicationMeta::from),
+            dc_creator: core.dc_creator,
+            dc_publisher: core.dc_publisher,
+            dc_rights: core.dc_rights,
         }
     }
 }

crates/feedparser-rs-py/src/types/feed_meta.rs

@@ -4,6 +4,7 @@ use pyo3::prelude::*;
 use super::common::{PyGenerator, PyImage, PyLink, PyPerson, PyTag, PyTextConstruct};
 use super::datetime::optional_datetime_to_struct_time;
 use super::podcast::{PyItunesFeedMeta, PyPodcastMeta};
+use super::syndication::PySyndicationMeta;
 
 #[pyclass(name = "FeedMeta", module = "feedparser_rs")]
 #[derive(Clone)]
@@ -212,6 +213,29 @@ impl PyFeedMeta {
         self.inner.license.as_deref()
     }
 
+    #[getter]
+    fn syndication(&self) -> Option<PySyndicationMeta> {
+        self.inner
+            .syndication
+            .as_ref()
+            .map(|s| PySyndicationMeta::from_core(s.clone()))
+    }
+
+    #[getter]
+    fn dc_creator(&self) -> Option<&str> {
+        self.inner.dc_creator.as_deref()
+    }
+
+    #[getter]
+    fn dc_publisher(&self) -> Option<&str> {
+        self.inner.dc_publisher.as_deref()
+    }
+
+    #[getter]
+    fn dc_rights(&self) -> Option<&str> {
+        self.inner.dc_rights.as_deref()
+    }
+
     fn __repr__(&self) -> String {
         format!(
             "FeedMeta(title='{}', link='{}')",

crates/feedparser-rs-py/src/types/mod.rs

@@ -4,5 +4,6 @@ pub mod entry;
 pub mod feed_meta;
 pub mod parsed_feed;
 pub mod podcast;
+pub mod syndication;
 
 pub use parsed_feed::PyParsedFeed;

crates/feedparser-rs-py/src/types/syndication.rs

@@ -0,0 +1,45 @@
+use feedparser_rs::SyndicationMeta as CoreSyndicationMeta;
+use pyo3::prelude::*;
+
+/// Syndication module metadata
+#[pyclass(name = "SyndicationMeta", module = "feedparser_rs")]
+#[derive(Clone)]
+pub struct PySyndicationMeta {
+    inner: CoreSyndicationMeta,
+}
+
+impl PySyndicationMeta {
+    pub fn from_core(core: CoreSyndicationMeta) -> Self {
+        Self { inner: core }
+    }
+}
+
+#[pymethods]
+impl PySyndicationMeta {
+    /// Update period (hourly, daily, weekly, monthly, yearly)
+    #[getter]
+    fn update_period(&self) -> Option<String> {
+        self.inner.update_period.map(|p| p.as_str().to_string())
+    }
+
+    /// Number of times updated per period
+    #[getter]
+    fn update_frequency(&self) -> Option<u32> {
+        self.inner.update_frequency
+    }
+
+    /// Base date for update schedule (ISO 8601)
+    #[getter]
+    fn update_base(&self) -> Option<&str> {
+        self.inner.update_base.as_deref()
+    }
+
+    fn __repr__(&self) -> String {
+        format!(
+            "SyndicationMeta(update_period={:?}, update_frequency={:?}, update_base={:?})",
+            self.update_period(),
+            self.update_frequency(),
+            self.update_base()
+        )
+    }
+}