feat(parser): add xml:lang tracking and license field support (#27)

* feat: complete *_detail structures with xml:lang and license support

Add comprehensive xml:lang tracking to RSS parser and license field
support across all feed formats to complete Phase 2 of *_detail
infrastructure.

Changes:
- Add extract_xml_lang() helper function to parser/common.rs
- Track xml:lang at RSS channel and item levels with inheritance
- Populate TextConstruct.language for title and description fields
- Add license field to FeedMeta and Entry types
- Parse creativeCommons:license and plain license tags in RSS
- Extract license from link rel="license" in Atom feeds
- Update Python and Node.js bindings with license getters
- Add comprehensive integration tests for xml:lang and license

The RSS parser now properly tracks xml:lang attributes on channel
and item elements, propagating language information to TextConstruct
fields. Item-level xml:lang overrides channel-level language, matching
standard XML behavior.

License URLs are extracted from both RSS (creativeCommons:license,
license tags) and Atom (link rel="license") feeds, stored in the
license field for both feed and entry metadata.

Tests: 476 passed, clippy clean, all CI checks passing

* fix(node): add license field to TypeScript definitions

Add missing license field to Entry and FeedMeta interfaces in TypeScript
definitions. This field was already implemented in the Rust code but was
not exposed in the type definitions.

Also add test for empty xml:lang attribute handling to verify edge case
behavior.

* style: apply nightly rustfmt formatting

Author: bug-ops

crates/feedparser-rs-core/src/parser/atom.rs

@@ -136,6 +136,10 @@ fn parse_feed_element(
                             {
                                 feed.feed.link = Some(link.href.clone());
                             }
+                            if feed.feed.license.is_none() && link.rel.as_deref() == Some("license")
+                            {
+                                feed.feed.license = Some(link.href.clone());
+                            }
                             feed.feed
                                 .links
                                 .try_push_limited(link, limits.max_links_per_feed);
@@ -305,6 +309,9 @@ fn parse_entry(
                             if entry.link.is_none() && link.rel.as_deref() == Some("alternate") {
                                 entry.link = Some(link.href.clone());
                             }
+                            if entry.license.is_none() && link.rel.as_deref() == Some("license") {
+                                entry.license = Some(link.href.clone());
+                            }
                             entry
                                 .links
                                 .try_push_limited(link, limits.max_links_per_entry);
@@ -926,4 +933,45 @@ mod tests {
         assert_eq!(feed.feed.links.len(), 1);
         assert_eq!(feed.feed.tags.len(), 1);
     }
+
+    #[test]
+    fn test_parse_atom_license_feed() {
+        let xml = br#"<?xml version="1.0"?>
+        <feed xmlns="http://www.w3.org/2005/Atom">
+            <title>Test Feed</title>
+            <link rel="license" href="https://creativecommons.org/licenses/by/4.0/"/>
+            <link rel="alternate" href="https://example.com/"/>
+        </feed>"#;
+
+        let feed = parse_atom10(xml).unwrap();
+        assert_eq!(
+            feed.feed.license.as_deref(),
+            Some("https://creativecommons.org/licenses/by/4.0/")
+        );
+        assert_eq!(feed.feed.link.as_deref(), Some("https://example.com/"));
+    }
+
+    #[test]
+    fn test_parse_atom_license_entry() {
+        let xml = br#"<?xml version="1.0"?>
+        <feed xmlns="http://www.w3.org/2005/Atom">
+            <entry>
+                <title>Licensed Entry</title>
+                <id>urn:uuid:1</id>
+                <link rel="license" href="https://creativecommons.org/licenses/by-sa/3.0/"/>
+                <link rel="alternate" href="https://example.com/entry/1"/>
+            </entry>
+        </feed>"#;
+
+        let feed = parse_atom10(xml).unwrap();
+        assert_eq!(feed.entries.len(), 1);
+        assert_eq!(
+            feed.entries[0].license.as_deref(),
+            Some("https://creativecommons.org/licenses/by-sa/3.0/")
+        );
+        assert_eq!(
+            feed.entries[0].link.as_deref(),
+            Some("https://example.com/entry/1")
+        );
+    }
 }

crates/feedparser-rs-core/src/parser/common.rs

@@ -285,6 +285,47 @@ pub fn extract_xml_base(
         .map(|s| s.to_string())
 }
 
+/// Extract xml:lang attribute from element
+///
+/// Returns the language code if xml:lang or lang attribute exists.
+/// Respects `max_attribute_length` limit for `DoS` protection.
+///
+/// # Arguments
+///
+/// * `element` - The XML element to extract xml:lang from
+/// * `max_attr_length` - Maximum allowed attribute length (`DoS` protection)
+///
+/// # Returns
+///
+/// * `Some(String)` - The xml:lang value if found and within length limit
+/// * `None` - If attribute not found or exceeds length limit
+///
+/// # Examples
+///
+/// ```ignore
+/// use feedparser_rs::parser::common::extract_xml_lang;
+///
+/// let element = /* BytesStart from quick-xml */;
+/// if let Some(lang) = extract_xml_lang(&element, 1024) {
+///     println!("Language: {}", lang);
+/// }
+/// ```
+pub fn extract_xml_lang(
+    element: &quick_xml::events::BytesStart,
+    max_attr_length: usize,
+) -> Option<String> {
+    element
+        .attributes()
+        .flatten()
+        .find(|attr| {
+            let key = attr.key.as_ref();
+            key == b"xml:lang" || key == b"lang"
+        })
+        .filter(|attr| attr.value.len() <= max_attr_length)
+        .and_then(|attr| attr.unescape_value().ok())
+        .map(|s| s.to_string())
+}
+
 /// Read text content from current XML element (handles text and CDATA)
 pub fn read_text(
     reader: &mut Reader<&[u8]>,