refactor: implement Phase 1 DRY improvements

This commit implements the low-hanging fruit refactorings from the DRY
analysis report, focusing on eliminating code duplication with minimal risk.

Changes:

1. Unify bytes_to_string() function
   - Moved implementation to util/text.rs as single source of truth
   - Removed duplicate implementations from parser/common.rs and types/common.rs
   - Added comprehensive documentation with examples
   - Re-exported from parser/common for backward compatibility
   - Lines saved: ~8

2. Add Person::from_name() helper method
   - Added convenience constructor for creating Person from just a name
   - Updated all 4 occurrences in namespace/dublin_core.rs to use helper
   - Reduces boilerplate and ensures consistent Person construction
   - Lines saved: ~10

3. Use Tag::new() builder method consistently
   - Tag::new() already existed but wasn't used everywhere
   - Updated 4 occurrences across namespace modules to use builder
   - Replaced verbose struct literal construction with concise builder
   - Lines saved: ~12

4. Add HTTP header helper method
   - Added insert_header() helper to reduce boilerplate in FeedHttpClient
   - Centralizes error handling for header value conversion
   - Updated get() method to use helper for User-Agent, ETag, and Last-Modified
   - Consistent error messages across all header insertions
   - Lines saved: ~15

Total impact:
- Lines reduced: ~45
- Files modified: 6
- Test coverage: All 302 tests pass
- Clippy: Clean with -D warnings
- Risk level: Low (backward compatible changes only)

These changes improve code maintainability and reduce the risk of
inconsistent behavior when similar operations are performed in different
parts of the codebase.

Author: bug-ops

crates/feedparser-rs-core/src/http/client.rs

@@ -3,7 +3,8 @@ use super::validation::validate_url;
 use crate::error::{FeedError, Result};
 use reqwest::blocking::{Client, Response};
 use reqwest::header::{
-    ACCEPT, ACCEPT_ENCODING, HeaderMap, HeaderValue, IF_MODIFIED_SINCE, IF_NONE_MATCH, USER_AGENT,
+    ACCEPT, ACCEPT_ENCODING, HeaderMap, HeaderName, HeaderValue, IF_MODIFIED_SINCE, IF_NONE_MATCH,
+    USER_AGENT,
 };
 use std::collections::HashMap;
 use std::time::Duration;
@@ -63,6 +64,25 @@ impl FeedHttpClient {
         self
     }
 
+    /// Insert header with consistent error handling
+    ///
+    /// Helper method to reduce boilerplate in header insertion.
+    #[inline]
+    fn insert_header(
+        headers: &mut HeaderMap,
+        name: HeaderName,
+        value: &str,
+        field_name: &str,
+    ) -> Result<()> {
+        headers.insert(
+            name,
+            HeaderValue::from_str(value).map_err(|e| FeedError::Http {
+                message: format!("Invalid {field_name}: {e}"),
+            })?,
+        );
+        Ok(())
+    }
+
     /// Fetches a feed from the given URL
     ///
     /// Supports conditional GET with `ETag` and `Last-Modified` headers.
@@ -91,12 +111,7 @@ impl FeedHttpClient {
         let mut headers = HeaderMap::new();
 
         // Standard headers
-        headers.insert(
-            USER_AGENT,
-            HeaderValue::from_str(&self.user_agent).map_err(|e| FeedError::Http {
-                message: format!("Invalid User-Agent: {e}"),
-            })?,
-        );
+        Self::insert_header(&mut headers, USER_AGENT, &self.user_agent, "User-Agent")?;
 
         headers.insert(
             ACCEPT,
@@ -112,21 +127,16 @@ impl FeedHttpClient {
 
         // Conditional GET headers
         if let Some(etag_val) = etag {
-            headers.insert(
-                IF_NONE_MATCH,
-                HeaderValue::from_str(etag_val).map_err(|e| FeedError::Http {
-                    message: format!("Invalid ETag: {e}"),
-                })?,
-            );
+            Self::insert_header(&mut headers, IF_NONE_MATCH, etag_val, "ETag")?;
         }
 
         if let Some(modified_val) = modified {
-            headers.insert(
+            Self::insert_header(
+                &mut headers,
                 IF_MODIFIED_SINCE,
-                HeaderValue::from_str(modified_val).map_err(|e| FeedError::Http {
-                    message: format!("Invalid Last-Modified: {e}"),
-                })?,
-            );
+                modified_val,
+                "Last-Modified",
+            )?;
         }
 
         // Merge extra headers

crates/feedparser-rs-core/src/namespace/dublin_core.rs

@@ -39,11 +39,7 @@ pub fn handle_feed_element(element: &str, text: &str, feed: &mut FeedMeta) {
             // Store in dc_creator field
             feed.dc_creator = Some(text.to_string());
             // Also add to authors list
-            feed.authors.push(Person {
-                name: Some(text.to_string()),
-                email: None,
-                uri: None,
-            });
+            feed.authors.push(Person::from_name(text));
         }
         "date" => {
             // dc:date → updated (if not already set)
@@ -55,11 +51,7 @@ pub fn handle_feed_element(element: &str, text: &str, feed: &mut FeedMeta) {
         }
         "subject" => {
             // dc:subject → tags
-            feed.tags.push(Tag {
-                term: text.to_string(),
-                scheme: None,
-                label: None,
-            });
+            feed.tags.push(Tag::new(text));
         }
         "description" => {
             // dc:description → subtitle (if not already set)
@@ -101,11 +93,7 @@ pub fn handle_feed_element(element: &str, text: &str, feed: &mut FeedMeta) {
         }
         "contributor" => {
             // dc:contributor → contributors
-            feed.contributors.push(Person {
-                name: Some(text.to_string()),
-                email: None,
-                uri: None,
-            });
+            feed.contributors.push(Person::from_name(text));
         }
         _ => {
             // Ignore unknown DC elements (source, type, format, coverage, etc.)
@@ -127,11 +115,7 @@ pub fn handle_entry_element(element: &str, text: &str, entry: &mut Entry) {
                 entry.author = Some(text.to_string());
             }
             entry.dc_creator = Some(text.to_string());
-            entry.authors.push(Person {
-                name: Some(text.to_string()),
-                email: None,
-                uri: None,
-            });
+            entry.authors.push(Person::from_name(text));
         }
         "date" => {
             if let Some(dt) = parse_date(text) {
@@ -144,11 +128,7 @@ pub fn handle_entry_element(element: &str, text: &str, entry: &mut Entry) {
         }
         "subject" => {
             entry.dc_subject.push(text.to_string());
-            entry.tags.push(Tag {
-                term: text.to_string(),
-                scheme: None,
-                label: None,
-            });
+            entry.tags.push(Tag::new(text));
         }
         "description" => {
             if entry.summary.is_none() {
@@ -166,11 +146,7 @@ pub fn handle_entry_element(element: &str, text: &str, entry: &mut Entry) {
             }
         }
         "contributor" => {
-            entry.contributors.push(Person {
-                name: Some(text.to_string()),
-                email: None,
-                uri: None,
-            });
+            entry.contributors.push(Person::from_name(text));
         }
         "rights" => {
             entry.dc_rights = Some(text.to_string());

crates/feedparser-rs-core/src/namespace/media_rss.rs

@@ -46,21 +46,13 @@ pub fn handle_entry_element(element: &str, text: &str, entry: &mut Entry) {
             for keyword in text.split(',') {
                 let keyword = keyword.trim();
                 if !keyword.is_empty() {
-                    entry.tags.push(Tag {
-                        term: keyword.to_string(),
-                        scheme: None,
-                        label: None,
-                    });
+                    entry.tags.push(Tag::new(keyword));
                 }
             }
         }
         "category" => {
             if !text.is_empty() {
-                entry.tags.push(Tag {
-                    term: text.to_string(),
-                    scheme: None,
-                    label: None,
-                });
+                entry.tags.push(Tag::new(text));
             }
         }
         _ => {

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

@@ -11,6 +11,7 @@ use crate::{
 use quick_xml::{Reader, events::Event};
 
 pub use crate::types::{FromAttributes, LimitedCollectionExt};
+pub use crate::util::text::bytes_to_string;
 
 /// Initial capacity for XML event buffer (fits most elements)
 pub const EVENT_BUFFER_CAPACITY: usize = 1024;
@@ -106,18 +107,6 @@ pub fn check_depth(depth: usize, max_depth: usize) -> Result<()> {
     Ok(())
 }
 
-/// Efficient string conversion from bytes - zero-copy for valid UTF-8
-///
-/// Uses `std::str::from_utf8()` for zero-copy conversion when the input
-/// is valid UTF-8, falling back to lossy conversion otherwise.
-#[inline]
-pub fn bytes_to_string(value: &[u8]) -> String {
-    std::str::from_utf8(value).map_or_else(
-        |_| String::from_utf8_lossy(value).into_owned(),
-        std::string::ToString::to_string,
-    )
-}
-
 /// Read text content from current XML element (handles text and CDATA)
 pub fn read_text(
     reader: &mut Reader<&[u8]>,

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

@@ -1,15 +1,7 @@
 use super::generics::{FromAttributes, ParseFrom};
+use crate::util::text::bytes_to_string;
 use serde_json::Value;
 
-/// Helper for efficient bytes to string conversion
-#[inline]
-fn bytes_to_string(value: &[u8]) -> String {
-    std::str::from_utf8(value).map_or_else(
-        |_| String::from_utf8_lossy(value).into_owned(),
-        std::string::ToString::to_string,
-    )
-}
-
 /// Link in feed or entry
 #[derive(Debug, Clone, Default)]
 pub struct Link {
@@ -99,6 +91,29 @@ pub struct Person {
     pub uri: Option<String>,
 }
 
+impl Person {
+    /// Create person from just a name
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use feedparser_rs_core::types::Person;
+    ///
+    /// let person = Person::from_name("John Doe");
+    /// assert_eq!(person.name.as_deref(), Some("John Doe"));
+    /// assert!(person.email.is_none());
+    /// assert!(person.uri.is_none());
+    /// ```
+    #[inline]
+    pub fn from_name(name: impl Into<String>) -> Self {
+        Self {
+            name: Some(name.into()),
+            email: None,
+            uri: None,
+        }
+    }
+}
+
 /// Tag/category
 #[derive(Debug, Clone)]
 pub struct Tag {

crates/feedparser-rs-core/src/util/text.rs

@@ -1,6 +1,29 @@
-// Text processing utilities
-//
-// This module will provide functions for text manipulation,
-// such as trimming, normalizing whitespace, etc.
+//! Text processing utilities
+//!
+//! This module provides functions for text manipulation,
+//! such as trimming, normalizing whitespace, and encoding conversion.
 
-// TODO: Implement as needed
+/// Efficient bytes to string conversion - zero-copy for valid UTF-8
+///
+/// Uses `std::str::from_utf8()` for zero-copy conversion when the input
+/// is valid UTF-8, falling back to lossy conversion otherwise.
+///
+/// # Examples
+///
+/// ```
+/// use feedparser_rs_core::util::text::bytes_to_string;
+///
+/// let valid_utf8 = b"Hello, world!";
+/// assert_eq!(bytes_to_string(valid_utf8), "Hello, world!");
+///
+/// let invalid_utf8 = &[0xFF, 0xFE, 0xFD];
+/// let result = bytes_to_string(invalid_utf8);
+/// assert!(!result.is_empty()); // Lossy conversion succeeded
+/// ```
+#[inline]
+pub fn bytes_to_string(value: &[u8]) -> String {
+    std::str::from_utf8(value).map_or_else(
+        |_| String::from_utf8_lossy(value).into_owned(),
+        std::string::ToString::to_string,
+    )
+}