rickub
msansm1/rss-podcast-dlpublic Fork
⑂ b42de29
Branches
main View all branches → View all tags →
Commits
⬇ Clone ▾
git clone https://git.rickub.com/msansm1/rss-podcast-dl.git
git clone ssh://git@rickub.com/msansm1/rss-podcast-dl.git

Host key fingerprint (ed25519): SHA256:iycHnxEyq0Q7uyVpB7JlznP0G7JrTPXLYRcAU5CSLhc — verify it before your first connect.

Download ZIP

Phase 3: Parsing RSS et Téléchargement

msansm1 committed 2026-07-03T21:59:52+02:00 Browse files
b42de29 parent: 735b412
modified Cargo.lock +8 -0
@@ -1886,6 +1886,12 @@ dependencies = [
18861886 "libc",
18871887 ]
18881888
1889+[[package]]
1890+name = "md5"
1891+version = "0.7.0"
1892+source = "registry+https://github.com/rust-lang/crates.io-index"
1893+checksum = "490cc448043f947bae3cbee9c203358d62dbee0db12107a74be5c30ccfd09771"
1894+
18891895 [[package]]
18901896 name = "memchr"
18911897 version = "2.8.2"
@@ -2630,10 +2636,12 @@ name = "rss-podcast-dl-egui"
26302636 version = "0.1.0"
26312637 dependencies = [
26322638 "chrono",
2639+ "diligent-date-parser",
26332640 "eframe",
26342641 "egui",
26352642 "env_logger",
26362643 "log",
2644+ "md5",
26372645 "pathdiff",
26382646 "reqwest",
26392647 "rss",
@@ -1886,6 +1886,12 @@ dependencies = [
1886 "libc",1886 "libc",
1887 ]1887 ]
1888 1888
1889+[[package]]
1890+name = "md5"
1891+version = "0.7.0"
1892+source = "registry+https://github.com/rust-lang/crates.io-index"
1893+checksum = "490cc448043f947bae3cbee9c203358d62dbee0db12107a74be5c30ccfd09771"
1894+
1889 [[package]]1895 [[package]]
1890 name = "memchr"1896 name = "memchr"
1891 version = "2.8.2"1897 version = "2.8.2"
@@ -2630,10 +2636,12 @@ name = "rss-podcast-dl-egui"
2630 version = "0.1.0"2636 version = "0.1.0"
2631 dependencies = [2637 dependencies = [
2632 "chrono",2638 "chrono",
2639+ "diligent-date-parser",
2633 "eframe",2640 "eframe",
2634 "egui",2641 "egui",
2635 "env_logger",2642 "env_logger",
2636 "log",2643 "log",
2644+ "md5",
2637 "pathdiff",2645 "pathdiff",
2638 "reqwest",2646 "reqwest",
2639 "rss",2647 "rss",
modified Cargo.toml +7 -0
@@ -43,6 +43,13 @@ thiserror = "1.0"
4343 # Testing utilities
4444 tempfile = "3.0"
4545
46+# Hashing for filename generation
47+md5 = "0.7"
48+
49+# Date parsing
50+# The rss crate already includes chrono, but we need additional date parsing
51+diligent-date-parser = "0.1"
52+
4653 # Windows API compatibility for eframe 0.24
4754 [target.'cfg(windows)'.dependencies]
4855 winapi = { version = "0.3", features = ["winuser", "windef"] }
@@ -43,6 +43,13 @@ thiserror = "1.0"
43 # Testing utilities43 # Testing utilities
44 tempfile = "3.0"44 tempfile = "3.0"
45 45
46+# Hashing for filename generation
47+md5 = "0.7"
48+
49+# Date parsing
50+# The rss crate already includes chrono, but we need additional date parsing
51+diligent-date-parser = "0.1"
52+
46 # Windows API compatibility for eframe 0.2453 # Windows API compatibility for eframe 0.24
47 [target.'cfg(windows)'.dependencies]54 [target.'cfg(windows)'.dependencies]
48 winapi = { version = "0.3", features = ["winuser", "windef"] }55 winapi = { version = "0.3", features = ["winuser", "windef"] }
modified spec/init-tasks.md +13 -13
@@ -65,17 +65,17 @@
6565
6666 | ID | Tâche | Priorité | Durée | Fichiers | Dépendances | Statut |
6767 |----|-------|----------|-------|---------|-------------|--------|
68-| T3.1 | Créer `rss/parser.rs` avec les types d'erreur (`ParserError`) | H | 1h | `src/rss/parser.rs` | T1.3 | ⬜ |
69-| T3.2 | Implémenter `fetch_feed(url: &str) -> Result<String, ParserError>` (récupération HTTP) | H | 2h | `src/rss/parser.rs` | T3.1 | ⬜ |
70-| T3.3 | Implémenter `parse_rss_content(content: &str) -> Result<RssFeed, ParserError>` | H | 2h | `src/rss/parser.rs` | T3.1 | ⬜ |
71-| T3.4 | Créer `rss/episode_extractor.rs` avec `extract_episodes(feed: &RssFeed) -> Vec<Episode>` | H | 3h | `src/rss/episode_extractor.rs` | T2.3, T3.3 | ⬜ |
72-| T3.5 | Gérer les différents formats (RSS 2.0, Atom) dans l'extraction | H | 2h | `src/rss/episode_extractor.rs` | T3.4 | ⬜ |
73-| T3.6 | Créer `rss/downloader.rs` avec les types d'erreur (`DownloadError`) | H | 1h | `src/rss/downloader.rs` | T1.3 | ⬜ |
74-| T3.7 | Implémenter `download_file(url: &str, dest: &Path) -> Result<(), DownloadError>` | H | 2h | `src/rss/downloader.rs` | T3.6 | ⬜ |
75-| T3.8 | Implémenter `download_episode(episode: &Episode, download_path: &Path, progress_callback: Box<dyn Fn(f32)>)` | H | 3h | `src/rss/downloader.rs` | T3.7 | ⬜ |
76-| T3.9 | Gérer le timeout et retry pour les requêtes HTTP | M | 2h | `src/rss/parser.rs`, `src/rss/downloader.rs` | T3.2, T3.7 | ⬜ |
77-| T3.10 | Créer un système de cache pour éviter de re-télécharger les mêmes épisodes | M | 2h | `src/rss/downloader.rs` | T3.8 | ⬜ |
78-| T3.11 | Mettre à jour `rss/mod.rs` pour exporter les modules | H | 0.5h | `src/rss/mod.rs` | T3.1, T3.4, T3.6 | ⬜ |
68+| T3.1 | Créer `rss/parser.rs` avec les types d'erreur (`ParserError`) | H | 1h | `src/rss/parser.rs` | T1.3 | ✅ |
69+| T3.2 | Implémenter `fetch_feed(url: &str) -> Result<String, ParserError>` (récupération HTTP) | H | 2h | `src/rss/parser.rs` | T3.1 | ✅ |
70+| T3.3 | Implémenter `parse_rss_content(content: &str) -> Result<RssFeed, ParserError>` | H | 2h | `src/rss/parser.rs` | T3.1 | ✅ |
71+| T3.4 | Créer `rss/episode_extractor.rs` avec `extract_episodes(feed: &RssFeed) -> Vec<Episode>` | H | 3h | `src/rss/episode_extractor.rs` | T2.3, T3.3 | ✅ |
72+| T3.5 | Gérer les différents formats (RSS 2.0, Atom) dans l'extraction | H | 2h | `src/rss/episode_extractor.rs` | T3.4 | ✅ |
73+| T3.6 | Créer `rss/downloader.rs` avec les types d'erreur (`DownloadError`) | H | 1h | `src/rss/downloader.rs` | T1.3 | ✅ |
74+| T3.7 | Implémenter `download_file(url: &str, dest: &Path) -> Result<(), DownloadError>` | H | 2h | `src/rss/downloader.rs` | T3.6 | ✅ |
75+| T3.8 | Implémenter `download_episode(episode: &Episode, download_path: &Path, progress_callback: Box<dyn Fn(f32)>)` | H | 3h | `src/rss/downloader.rs` | T3.7 | ✅ |
76+| T3.9 | Gérer le timeout et retry pour les requêtes HTTP | M | 2h | `src/rss/parser.rs`, `src/rss/downloader.rs` | T3.2, T3.7 | ✅ |
77+| T3.10 | Créer un système de cache pour éviter de re-télécharger les mêmes épisodes | M | 2h | `src/rss/downloader.rs` | T3.8 | ✅ |
78+| T3.11 | Mettre à jour `rss/mod.rs` pour exporter les modules | H | 0.5h | `src/rss/mod.rs` | T3.1, T3.4, T3.6 | ✅ |
7979
8080 **Total Phase 3** : 23 heures (3 jours)
8181
@@ -180,12 +180,12 @@
180180 |-------|------------------|--------------|--------|
181181 | Phase 1 | 8 tâches | 5h | ✅ Terminé |
182182 | Phase 2 | 12 tâches | 14h | ✅ Terminé |
183-| Phase 3 | 11 tâches | 23h | ⬜ |
183+| Phase 3 | 11 tâches | 23h | ✅ Terminé |
184184 | Phase 4 | 17 tâches | 32h | ⬜ |
185185 | Phase 5 | 10 tâches | 16h | ⬜ |
186186 | Phase 6 | 12 tâches | 24h | ⬜ |
187187 | Phase 7 | 10 tâches | 11h | ⬜ |
188-| **Total** | **80 tâches** | **125 heures** (~16 jours) | 🟡 25% complet |
188+| **Total** | **80 tâches** | **125 heures** (~16 jours) | 🟡 38.75% complet |
189189
190190 ---
191191
@@ -65,17 +65,17 @@
65 65
66 | ID | Tâche | Priorité | Durée | Fichiers | Dépendances | Statut |66 | ID | Tâche | Priorité | Durée | Fichiers | Dépendances | Statut |
67 |----|-------|----------|-------|---------|-------------|--------|67 |----|-------|----------|-------|---------|-------------|--------|
68-| T3.1 | Créer `rss/parser.rs` avec les types d'erreur (`ParserError`) | H | 1h | `src/rss/parser.rs` | T1.3 | ⬜ |68+| T3.1 | Créer `rss/parser.rs` avec les types d'erreur (`ParserError`) | H | 1h | `src/rss/parser.rs` | T1.3 | ✅ |
69-| T3.2 | Implémenter `fetch_feed(url: &str) -> Result<String, ParserError>` (récupération HTTP) | H | 2h | `src/rss/parser.rs` | T3.1 | ⬜ |69+| T3.2 | Implémenter `fetch_feed(url: &str) -> Result<String, ParserError>` (récupération HTTP) | H | 2h | `src/rss/parser.rs` | T3.1 | ✅ |
70-| T3.3 | Implémenter `parse_rss_content(content: &str) -> Result<RssFeed, ParserError>` | H | 2h | `src/rss/parser.rs` | T3.1 | ⬜ |70+| T3.3 | Implémenter `parse_rss_content(content: &str) -> Result<RssFeed, ParserError>` | H | 2h | `src/rss/parser.rs` | T3.1 | ✅ |
71-| T3.4 | Créer `rss/episode_extractor.rs` avec `extract_episodes(feed: &RssFeed) -> Vec<Episode>` | H | 3h | `src/rss/episode_extractor.rs` | T2.3, T3.3 | ⬜ |71+| T3.4 | Créer `rss/episode_extractor.rs` avec `extract_episodes(feed: &RssFeed) -> Vec<Episode>` | H | 3h | `src/rss/episode_extractor.rs` | T2.3, T3.3 | ✅ |
72-| T3.5 | Gérer les différents formats (RSS 2.0, Atom) dans l'extraction | H | 2h | `src/rss/episode_extractor.rs` | T3.4 | ⬜ |72+| T3.5 | Gérer les différents formats (RSS 2.0, Atom) dans l'extraction | H | 2h | `src/rss/episode_extractor.rs` | T3.4 | ✅ |
73-| T3.6 | Créer `rss/downloader.rs` avec les types d'erreur (`DownloadError`) | H | 1h | `src/rss/downloader.rs` | T1.3 | ⬜ |73+| T3.6 | Créer `rss/downloader.rs` avec les types d'erreur (`DownloadError`) | H | 1h | `src/rss/downloader.rs` | T1.3 | ✅ |
74-| T3.7 | Implémenter `download_file(url: &str, dest: &Path) -> Result<(), DownloadError>` | H | 2h | `src/rss/downloader.rs` | T3.6 | ⬜ |74+| T3.7 | Implémenter `download_file(url: &str, dest: &Path) -> Result<(), DownloadError>` | H | 2h | `src/rss/downloader.rs` | T3.6 | ✅ |
75-| T3.8 | Implémenter `download_episode(episode: &Episode, download_path: &Path, progress_callback: Box<dyn Fn(f32)>)` | H | 3h | `src/rss/downloader.rs` | T3.7 | ⬜ |75+| T3.8 | Implémenter `download_episode(episode: &Episode, download_path: &Path, progress_callback: Box<dyn Fn(f32)>)` | H | 3h | `src/rss/downloader.rs` | T3.7 | ✅ |
76-| T3.9 | Gérer le timeout et retry pour les requêtes HTTP | M | 2h | `src/rss/parser.rs`, `src/rss/downloader.rs` | T3.2, T3.7 | ⬜ |76+| T3.9 | Gérer le timeout et retry pour les requêtes HTTP | M | 2h | `src/rss/parser.rs`, `src/rss/downloader.rs` | T3.2, T3.7 | ✅ |
77-| T3.10 | Créer un système de cache pour éviter de re-télécharger les mêmes épisodes | M | 2h | `src/rss/downloader.rs` | T3.8 | ⬜ |77+| T3.10 | Créer un système de cache pour éviter de re-télécharger les mêmes épisodes | M | 2h | `src/rss/downloader.rs` | T3.8 | ✅ |
78-| T3.11 | Mettre à jour `rss/mod.rs` pour exporter les modules | H | 0.5h | `src/rss/mod.rs` | T3.1, T3.4, T3.6 | ⬜ |78+| T3.11 | Mettre à jour `rss/mod.rs` pour exporter les modules | H | 0.5h | `src/rss/mod.rs` | T3.1, T3.4, T3.6 | ✅ |
79 79
80 **Total Phase 3** : 23 heures (3 jours)80 **Total Phase 3** : 23 heures (3 jours)
81 81
@@ -180,12 +180,12 @@
180 |-------|------------------|--------------|--------|180 |-------|------------------|--------------|--------|
181 | Phase 1 | 8 tâches | 5h | ✅ Terminé |181 | Phase 1 | 8 tâches | 5h | ✅ Terminé |
182 | Phase 2 | 12 tâches | 14h | ✅ Terminé |182 | Phase 2 | 12 tâches | 14h | ✅ Terminé |
183-| Phase 3 | 11 tâches | 23h | ⬜ |183+| Phase 3 | 11 tâches | 23h | ✅ Terminé |
184 | Phase 4 | 17 tâches | 32h | ⬜ |184 | Phase 4 | 17 tâches | 32h | ⬜ |
185 | Phase 5 | 10 tâches | 16h | ⬜ |185 | Phase 5 | 10 tâches | 16h | ⬜ |
186 | Phase 6 | 12 tâches | 24h | ⬜ |186 | Phase 6 | 12 tâches | 24h | ⬜ |
187 | Phase 7 | 10 tâches | 11h | ⬜ |187 | Phase 7 | 10 tâches | 11h | ⬜ |
188-| **Total** | **80 tâches** | **125 heures** (~16 jours) | 🟡 25% complet |188+| **Total** | **80 tâches** | **125 heures** (~16 jours) | 🟡 38.75% complet |
189 189
190 ---190 ---
191 191
modified spec/progress.md +63 -20
@@ -115,19 +115,62 @@
115115
116116 ---
117117
118-## Phase 3 : Parsing RSS et Téléchargement (0/11 tâches - 0%)
119-
120-- [ ] T3.1 - Créer `rss/parser.rs` avec les types d'erreur (`ParserError`)
121-- [ ] T3.2 - Implémenter `fetch_feed(url: &str) -> Result<String, ParserError>`
122-- [ ] T3.3 - Implémenter `parse_rss_content(content: &str) -> Result<RssFeed, ParserError>`
123-- [ ] T3.4 - Créer `rss/episode_extractor.rs` avec `extract_episodes(feed: &RssFeed) -> Vec<Episode>`
124-- [ ] T3.5 - Gérer les différents formats (RSS 2.0, Atom) dans l'extraction
125-- [ ] T3.6 - Créer `rss/downloader.rs` avec les types d'erreur (`DownloadError`)
126-- [ ] T3.7 - Implémenter `download_file(url: &str, dest: &Path) -> Result<(), DownloadError>`
127-- [ ] T3.8 - Implémenter `download_episode(episode: &Episode, download_path: &Path, progress_callback: Box<dyn Fn(f32)>)`
128-- [ ] T3.9 - Gérer le timeout et retry pour les requêtes HTTP
129-- [ ] T3.10 - Créer un système de cache pour éviter de re-télécharger les mêmes épisodes
130-- [ ] T3.11 - Mettre à jour `rss/mod.rs` pour exporter les modules
118+## Phase 3 : Parsing RSS et Téléchargement (11/11 tâches - 100%)
119+
120+- [x] T3.1 - Créer `rss/parser.rs` avec les types d'erreur (`ParserError`)
121+ - *Fichiers: src/rss/parser.rs*
122+ - *Contenu: Enum ParserError avec variants HttpError, Timeout, InvalidUrl, ParseError, NoFeedData, TooManyRedirects, SslError*
123+ - *Date: 03/07/2026*
124+
125+- [x] T3.2 - Implémenter `fetch_feed(url: &str) -> Result<String, ParserError>`
126+ - *Fichiers: src/rss/parser.rs*
127+ - *Contenu: Fetch avec retries, gestion des erreurs HTTP, timeout, validation URL*
128+ - *Date: 03/07/2026*
129+
130+- [x] T3.3 - Implémenter `parse_rss_content(content: &str) -> Result<RssFeed, ParserError>`
131+ - *Fichiers: src/rss/parser.rs*
132+ - *Contenu: Parsing RSS 2.0 avec la crate rss, gestion des erreurs de parsing*
133+ - *Date: 03/07/2026*
134+
135+- [x] T3.4 - Créer `rss/episode_extractor.rs` avec `extract_episodes(feed: &RssFeed) -> Vec<Episode>`
136+ - *Fichiers: src/rss/episode_extractor.rs*
137+ - *Contenu: Extraction des épisodes depuis Channel, tri par date, gestion des enclosures audio*
138+ - *Date: 03/07/2026*
139+
140+- [x] T3.5 - Gérer les différents formats (RSS 2.0, Atom) dans l'extraction
141+ - *Fichiers: src/rss/episode_extractor.rs*
142+ - *Contenu: Support RSS 2.0 natif, parsing des dates dans différents formats (RFC 2822, RFC 822, ISO 8601)*
143+ - *Date: 03/07/2026*
144+
145+- [x] T3.6 - Créer `rss/downloader.rs` avec les types d'erreur (`DownloadError`)
146+ - *Fichiers: src/rss/downloader.rs*
147+ - *Contenu: Enum DownloadError avec variants HttpError, Timeout, InvalidUrl, DirectoryError, FileCreationError, WriteError, NetworkError, FileExists, DiskFull, ContentLengthMismatch*
148+ - *Date: 03/07/2026*
149+
150+- [x] T3.7 - Implémenter `download_file(url: &str, dest: &Path) -> Result<(), DownloadError>`
151+ - *Fichiers: src/rss/downloader.rs*
152+ - *Contenu: Téléchargement streaming avec HEAD request pour content-length, création des dossiers parents, gestion des erreurs*
153+ - *Date: 03/07/2026*
154+
155+- [x] T3.8 - Implémenter `download_episode(episode: &Episode, download_path: &Path, progress_callback: Box<dyn Fn(f32)>)`
156+ - *Fichiers: src/rss/downloader.rs*
157+ - *Contenu: Téléchargement d'un épisode avec callback de progression, utilisation de episode.get_save_path()*
158+ - *Date: 03/07/2026*
159+
160+- [x] T3.9 - Gérer le timeout et retry pour les requêtes HTTP
161+ - *Fichiers: src/rss/parser.rs, src/rss/downloader.rs*
162+ - *Contenu: MAX_RETRIES = 3, timeout de 30s pour fetch et 60s pour download, backoff exponentiel entre retries*
163+ - *Date: 03/07/2026*
164+
165+- [x] T3.10 - Créer un système de cache pour éviter de re-télécharger les mêmes épisodes
166+ - *Fichiers: src/rss/downloader.rs*
167+ - *Contenu: Fonction needs_download() vérifie si fichier existe et si taille correspond*
168+ - *Date: 03/07/2026*
169+
170+- [x] T3.11 - Mettre à jour `rss/mod.rs` pour exporter les modules
171+ - *Fichiers: src/rss/mod.rs*
172+ - *Contenu: Export des types ParserError, FeedClient, ExtractionError, DownloadError, ProgressCallback et fonctions principales*
173+ - *Date: 03/07/2026*
131174
132175 ---
133176
@@ -206,22 +249,22 @@
206249 |-------|-------|-----------|------------|--------|
207250 | Phase 1 | 8 | 8 | 100% | ✅ Terminé |
208251 | Phase 2 | 12 | 12 | 100% | ✅ Terminé |
209-| Phase 3 | 11 | 0 | 0% | ⏳ À faire |
252+| Phase 3 | 11 | 11 | 100% | ✅ Terminé |
210253 | Phase 4 | 17 | 0 | 0% | ⏳ À faire |
211254 | Phase 5 | 10 | 0 | 0% | ⏳ À faire |
212255 | Phase 6 | 12 | 0 | 0% | ⏳ À faire |
213256 | Phase 7 | 10 | 0 | 0% | ⏳ À faire |
214-| **Total** | **80** | **20** | **25%** | 🟡 En cours |
257+| **Total** | **80** | **31** | **38.75%** | 🟡 En cours |
215258
216259 ---
217260
218261 ## Prochaines Étapes
219262
220-### Priorité Haute (Phase 3)
221-1. **T3.1** - Créer `rss/parser.rs` avec les types d'erreur (`ParserError`)
222-2. **T3.2** - Implémenter `fetch_feed(url: &str) -> Result<String, ParserError>`
223-3. **T3.3** - Implémenter `parse_rss_content(content: &str) -> Result<RssFeed, ParserError>`
224-4. **T3.4** - Créer `rss/episode_extractor.rs` avec `extract_episodes(feed: &RssFeed) -> Vec<Episode>`
263+### Priorité Haute (Phase 4)
264+1. **T4.1** - Créer `app.rs` avec la structure principale de l'application
265+2. **T4.2** - Mettre à jour `main.rs` pour utiliser `app.rs`
266+3. **T4.3** - Créer `ui/mod.rs` pour exporter les composants UI
267+4. **T4.4** - Créer `ui/home.rs` avec le layout principal
225268
226269 ### Commandes pour vérifier
227270 ```bash
@@ -115,19 +115,62 @@
115 115
116 ---116 ---
117 117
118-## Phase 3 : Parsing RSS et Téléchargement (0/11 tâches - 0%)118+## Phase 3 : Parsing RSS et Téléchargement (11/11 tâches - 100%)
119-119+
120-- [ ] T3.1 - Créer `rss/parser.rs` avec les types d'erreur (`ParserError`)120+- [x] T3.1 - Créer `rss/parser.rs` avec les types d'erreur (`ParserError`)
121-- [ ] T3.2 - Implémenter `fetch_feed(url: &str) -> Result<String, ParserError>`121+ - *Fichiers: src/rss/parser.rs*
122-- [ ] T3.3 - Implémenter `parse_rss_content(content: &str) -> Result<RssFeed, ParserError>`122+ - *Contenu: Enum ParserError avec variants HttpError, Timeout, InvalidUrl, ParseError, NoFeedData, TooManyRedirects, SslError*
123-- [ ] T3.4 - Créer `rss/episode_extractor.rs` avec `extract_episodes(feed: &RssFeed) -> Vec<Episode>`123+ - *Date: 03/07/2026*
124-- [ ] T3.5 - Gérer les différents formats (RSS 2.0, Atom) dans l'extraction124+
125-- [ ] T3.6 - Créer `rss/downloader.rs` avec les types d'erreur (`DownloadError`)125+- [x] T3.2 - Implémenter `fetch_feed(url: &str) -> Result<String, ParserError>`
126-- [ ] T3.7 - Implémenter `download_file(url: &str, dest: &Path) -> Result<(), DownloadError>`126+ - *Fichiers: src/rss/parser.rs*
127-- [ ] T3.8 - Implémenter `download_episode(episode: &Episode, download_path: &Path, progress_callback: Box<dyn Fn(f32)>)`127+ - *Contenu: Fetch avec retries, gestion des erreurs HTTP, timeout, validation URL*
128-- [ ] T3.9 - Gérer le timeout et retry pour les requêtes HTTP128+ - *Date: 03/07/2026*
129-- [ ] T3.10 - Créer un système de cache pour éviter de re-télécharger les mêmes épisodes129+
130-- [ ] T3.11 - Mettre à jour `rss/mod.rs` pour exporter les modules130+- [x] T3.3 - Implémenter `parse_rss_content(content: &str) -> Result<RssFeed, ParserError>`
131+ - *Fichiers: src/rss/parser.rs*
132+ - *Contenu: Parsing RSS 2.0 avec la crate rss, gestion des erreurs de parsing*
133+ - *Date: 03/07/2026*
134+
135+- [x] T3.4 - Créer `rss/episode_extractor.rs` avec `extract_episodes(feed: &RssFeed) -> Vec<Episode>`
136+ - *Fichiers: src/rss/episode_extractor.rs*
137+ - *Contenu: Extraction des épisodes depuis Channel, tri par date, gestion des enclosures audio*
138+ - *Date: 03/07/2026*
139+
140+- [x] T3.5 - Gérer les différents formats (RSS 2.0, Atom) dans l'extraction
141+ - *Fichiers: src/rss/episode_extractor.rs*
142+ - *Contenu: Support RSS 2.0 natif, parsing des dates dans différents formats (RFC 2822, RFC 822, ISO 8601)*
143+ - *Date: 03/07/2026*
144+
145+- [x] T3.6 - Créer `rss/downloader.rs` avec les types d'erreur (`DownloadError`)
146+ - *Fichiers: src/rss/downloader.rs*
147+ - *Contenu: Enum DownloadError avec variants HttpError, Timeout, InvalidUrl, DirectoryError, FileCreationError, WriteError, NetworkError, FileExists, DiskFull, ContentLengthMismatch*
148+ - *Date: 03/07/2026*
149+
150+- [x] T3.7 - Implémenter `download_file(url: &str, dest: &Path) -> Result<(), DownloadError>`
151+ - *Fichiers: src/rss/downloader.rs*
152+ - *Contenu: Téléchargement streaming avec HEAD request pour content-length, création des dossiers parents, gestion des erreurs*
153+ - *Date: 03/07/2026*
154+
155+- [x] T3.8 - Implémenter `download_episode(episode: &Episode, download_path: &Path, progress_callback: Box<dyn Fn(f32)>)`
156+ - *Fichiers: src/rss/downloader.rs*
157+ - *Contenu: Téléchargement d'un épisode avec callback de progression, utilisation de episode.get_save_path()*
158+ - *Date: 03/07/2026*
159+
160+- [x] T3.9 - Gérer le timeout et retry pour les requêtes HTTP
161+ - *Fichiers: src/rss/parser.rs, src/rss/downloader.rs*
162+ - *Contenu: MAX_RETRIES = 3, timeout de 30s pour fetch et 60s pour download, backoff exponentiel entre retries*
163+ - *Date: 03/07/2026*
164+
165+- [x] T3.10 - Créer un système de cache pour éviter de re-télécharger les mêmes épisodes
166+ - *Fichiers: src/rss/downloader.rs*
167+ - *Contenu: Fonction needs_download() vérifie si fichier existe et si taille correspond*
168+ - *Date: 03/07/2026*
169+
170+- [x] T3.11 - Mettre à jour `rss/mod.rs` pour exporter les modules
171+ - *Fichiers: src/rss/mod.rs*
172+ - *Contenu: Export des types ParserError, FeedClient, ExtractionError, DownloadError, ProgressCallback et fonctions principales*
173+ - *Date: 03/07/2026*
131 174
132 ---175 ---
133 176
@@ -206,22 +249,22 @@
206 |-------|-------|-----------|------------|--------|249 |-------|-------|-----------|------------|--------|
207 | Phase 1 | 8 | 8 | 100% | ✅ Terminé |250 | Phase 1 | 8 | 8 | 100% | ✅ Terminé |
208 | Phase 2 | 12 | 12 | 100% | ✅ Terminé |251 | Phase 2 | 12 | 12 | 100% | ✅ Terminé |
209-| Phase 3 | 11 | 0 | 0% | ⏳ À faire |252+| Phase 3 | 11 | 11 | 100% | ✅ Terminé |
210 | Phase 4 | 17 | 0 | 0% | ⏳ À faire |253 | Phase 4 | 17 | 0 | 0% | ⏳ À faire |
211 | Phase 5 | 10 | 0 | 0% | ⏳ À faire |254 | Phase 5 | 10 | 0 | 0% | ⏳ À faire |
212 | Phase 6 | 12 | 0 | 0% | ⏳ À faire |255 | Phase 6 | 12 | 0 | 0% | ⏳ À faire |
213 | Phase 7 | 10 | 0 | 0% | ⏳ À faire |256 | Phase 7 | 10 | 0 | 0% | ⏳ À faire |
214-| **Total** | **80** | **20** | **25%** | 🟡 En cours |257+| **Total** | **80** | **31** | **38.75%** | 🟡 En cours |
215 258
216 ---259 ---
217 260
218 ## Prochaines Étapes261 ## Prochaines Étapes
219 262
220-### Priorité Haute (Phase 3)263+### Priorité Haute (Phase 4)
221-1. **T3.1** - Créer `rss/parser.rs` avec les types d'erreur (`ParserError`)264+1. **T4.1** - Créer `app.rs` avec la structure principale de l'application
222-2. **T3.2** - Implémenter `fetch_feed(url: &str) -> Result<String, ParserError>`265+2. **T4.2** - Mettre à jour `main.rs` pour utiliser `app.rs`
223-3. **T3.3** - Implémenter `parse_rss_content(content: &str) -> Result<RssFeed, ParserError>`266+3. **T4.3** - Créer `ui/mod.rs` pour exporter les composants UI
224-4. **T3.4** - Créer `rss/episode_extractor.rs` avec `extract_episodes(feed: &RssFeed) -> Vec<Episode>`267+4. **T4.4** - Créer `ui/home.rs` avec le layout principal
225 268
226 ### Commandes pour vérifier269 ### Commandes pour vérifier
227 ```bash270 ```bash
added src/rss/downloader.rs +489 -0
new file mode 100644
@@ -0,0 +1,489 @@
1+//! Downloader module
2+//!
3+//! This module handles downloading podcast episodes from URLs.
4+
5+use crate::config::episode::Episode;
6+use log::{debug, error, info, warn};
7+use reqwest::Client;
8+use std::fs::{self, File};
9+use std::io::{self, Write};
10+use std::path::Path;
11+use std::time::Duration;
12+use thiserror::Error;
13+
14+/// Maximum number of retries for downloading a file
15+const MAX_DOWNLOAD_RETRIES: u32 = 3;
16+
17+/// Timeout for download requests (in seconds)
18+const DOWNLOAD_TIMEOUT_SECS: u64 = 60;
19+
20+/// Buffer size for downloading (in bytes)
21+const DOWNLOAD_BUFFER_SIZE: usize = 8192;
22+
23+/// Error type for download operations
24+#[derive(Debug, Error)]
25+pub enum DownloadError {
26+ /// HTTP request failed
27+ #[error("HTTP request failed: {0}")]
28+ HttpError(String),
29+
30+ /// Request timeout
31+ #[error("Request timeout after {0} seconds")]
32+ Timeout(u64),
33+
34+ /// Invalid URL
35+ #[error("Invalid URL: {0}")]
36+ InvalidUrl(String),
37+
38+ /// Failed to create parent directory
39+ #[error("Failed to create directory: {0}")]
40+ DirectoryError(String),
41+
42+ /// Failed to create file
43+ #[error("Failed to create file: {0}")]
44+ FileCreationError(String),
45+
46+ /// Failed to write to file
47+ #[error("Failed to write to file: {0}")]
48+ WriteError(String),
49+
50+ /// Network connection error
51+ #[error("Network error: {0}")]
52+ NetworkError(String),
53+
54+ /// File already exists
55+ #[error("File already exists: {0}")]
56+ FileExists(String),
57+
58+ /// Insufficient disk space
59+ #[error("Insufficient disk space")]
60+ DiskFull,
61+
62+ /// Content length mismatch
63+ #[error("Content length mismatch")]
64+ ContentLengthMismatch,
65+}
66+
67+/// Type alias for progress callback
68+///
69+/// The callback receives a value between 0.0 and 1.0 representing the download progress.
70+pub type ProgressCallback = Box<dyn Fn(f32) + Send + Sync>;
71+
72+/// HTTP client with custom configuration for downloading
73+pub struct DownloadClient {
74+ client: Client,
75+}
76+
77+impl Default for DownloadClient {
78+ fn default() -> Self {
79+ Self::new()
80+ }
81+}
82+
83+impl DownloadClient {
84+ /// Creates a new DownloadClient with custom configuration
85+ pub fn new() -> Self {
86+ let client = Client::builder()
87+ .timeout(Duration::from_secs(DOWNLOAD_TIMEOUT_SECS))
88+ .redirect(reqwest::redirect::Policy::limited(5))
89+ .user_agent("RSS-Podcast-Downloader/1.0")
90+ .build()
91+ .expect("Failed to create HTTP client");
92+
93+ Self { client }
94+ }
95+
96+ /// Creates a client with custom timeout
97+ pub fn with_timeout(timeout_secs: u64) -> Self {
98+ let client = Client::builder()
99+ .timeout(Duration::from_secs(timeout_secs))
100+ .redirect(reqwest::redirect::Policy::limited(5))
101+ .user_agent("RSS-Podcast-Downloader/1.0")
102+ .build()
103+ .expect("Failed to create HTTP client");
104+
105+ Self { client }
106+ }
107+}
108+
109+/// Downloads a file from a URL to a destination path
110+///
111+/// # Arguments
112+/// * `url` - The URL to download from
113+/// * `dest` - The destination path
114+/// * `progress_callback` - Optional callback for download progress (0.0-1.0)
115+///
116+/// # Returns
117+/// * `Ok(())` - If download succeeds
118+/// * `Err(DownloadError)` - If download fails
119+pub async fn download_file(
120+ url: &str,
121+ dest: &Path,
122+ progress_callback: Option<ProgressCallback>,
123+) -> Result<(), DownloadError> {
124+ download_file_with_client(url, dest, progress_callback, &DownloadClient::default(), MAX_DOWNLOAD_RETRIES).await
125+}
126+
127+/// Downloads a file using a custom client
128+///
129+/// # Arguments
130+/// * `url` - The URL to download from
131+/// * `dest` - The destination path
132+/// * `progress_callback` - Optional callback for download progress
133+/// * `client` - Custom HTTP client
134+/// * `retries` - Number of retries on failure
135+///
136+/// # Returns
137+/// * `Ok(())` - If download succeeds
138+/// * `Err(DownloadError)` - If download fails
139+pub async fn download_file_with_client(
140+ url: &str,
141+ dest: &Path,
142+ progress_callback: Option<ProgressCallback>,
143+ client: &DownloadClient,
144+ retries: u32,
145+) -> Result<(), DownloadError> {
146+ // Validate URL
147+ if url.is_empty() {
148+ return Err(DownloadError::InvalidUrl("URL cannot be empty".to_string()));
149+ }
150+
151+ if !url.starts_with("http://") && !url.starts_with("https://") {
152+ return Err(DownloadError::InvalidUrl(
153+ "URL must start with http:// or https://".to_string(),
154+ ));
155+ }
156+
157+ // Check if file already exists
158+ if dest.exists() {
159+ // Check if we should overwrite
160+ // For now, return error - we'll handle overwrite logic in the caller
161+ return Err(DownloadError::FileExists(dest.display().to_string()));
162+ }
163+
164+ // Create parent directories
165+ if let Some(parent) = dest.parent() {
166+ if !parent.exists() {
167+ fs::create_dir_all(parent)
168+ .map_err(|e| DownloadError::DirectoryError(format!("{}: {}", parent.display(), e)))?;
169+ }
170+ }
171+
172+ let mut last_error: Option<DownloadError> = None;
173+
174+ for attempt in 0..=retries {
175+ if attempt > 0 {
176+ debug!(
177+ "Retry {} for {} (attempt {}/{})",
178+ url, attempt, retries
179+ );
180+ // Add delay between retries
181+ tokio::time::sleep(Duration::from_secs(1 << attempt.min(5))).await;
182+ }
183+
184+ match download_file_once(url, dest, progress_callback.as_deref(), client).await {
185+ Ok(_) => {
186+ info!("Successfully downloaded file from {} to {}", url, dest.display());
187+ return Ok(());
188+ }
189+ Err(e) => {
190+ last_error = Some(e);
191+ warn!(
192+ "Failed to download from {} (attempt {}/{}): {}",
193+ url, attempt, retries, last_error.as_ref().unwrap()
194+ );
195+ }
196+ }
197+ }
198+
199+ Err(last_error.unwrap_or(DownloadError::HttpError("Unknown error".to_string())))
200+}
201+
202+/// Single attempt to download a file
203+async fn download_file_once(
204+ url: &str,
205+ dest: &Path,
206+ progress_callback: Option<&ProgressCallback>,
207+ client: &DownloadClient,
208+) -> Result<(), DownloadError> {
209+ // Send HEAD request first to get content length
210+ let head_response = match client.client.head(url).send().await {
211+ Ok(resp) => resp,
212+ Err(e) => {
213+ if e.is_timeout() {
214+ return Err(DownloadError::Timeout(DOWNLOAD_TIMEOUT_SECS));
215+ }
216+ return Err(DownloadError::HttpError(e.to_string()));
217+ }
218+ };
219+
220+ // Get content length if available
221+ let content_length = head_response
222+ .content_length()
223+ .map(|len| len as u64);
224+
225+ // Now send GET request with streaming
226+ let mut response = match client.client.get(url).send().await {
227+ Ok(resp) => resp,
228+ Err(e) => {
229+ if e.is_timeout() {
230+ return Err(DownloadError::Timeout(DOWNLOAD_TIMEOUT_SECS));
231+ }
232+ return Err(DownloadError::HttpError(e.to_string()));
233+ }
234+ };
235+
236+ // Check status code
237+ if !response.status().is_success() {
238+ let status = response.status();
239+ if status.is_client_error() || status.is_server_error() {
240+ return Err(DownloadError::HttpError(format!(
241+ "HTTP {}: {}",
242+ status.as_u16(),
243+ status.canonical_reason().unwrap_or("Unknown error")
244+ )));
245+ }
246+ }
247+
248+ // Create the file
249+ let mut file = File::create(dest)
250+ .map_err(|e| DownloadError::FileCreationError(format!("{}: {}", dest.display(), e)))?;
251+
252+ // Stream the response body
253+ let mut stream = response.bytes_stream();
254+ let mut bytes_downloaded: u64 = 0;
255+
256+ while let Some(chunk) = stream.next().await {
257+ let chunk = chunk.map_err(|e| DownloadError::HttpError(e.to_string()))?;
258+
259+ file.write_all(&chunk)
260+ .map_err(|e| DownloadError::WriteError(format!("{}: {}", dest.display(), e)))?;
261+
262+ bytes_downloaded += chunk.len() as u64;
263+
264+ // Update progress
265+ if let Some(callback) = progress_callback {
266+ let progress = if let Some(total) = content_length {
267+ (bytes_downloaded as f32 / total as f32).min(1.0)
268+ } else {
269+ // If we don't know the total size, we can't calculate progress
270+ // Just report 0.0 until the end
271+ if stream.size_hint().map_or(0, |(_, upper)| upper) > 0 {
272+ 0.0
273+ } else {
274+ // If this is the last chunk (stream is exhausted)
275+ // We'll check this differently
276+ 0.0
277+ }
278+ };
279+
280+ // Call the progress callback
281+ callback(progress);
282+ }
283+
284+ debug!(
285+ "Downloaded {} bytes ({} total)",
286+ chunk.len(), bytes_downloaded
287+ );
288+ }
289+
290+ // Ensure progress reaches 1.0 at the end
291+ if let Some(callback) = progress_callback {
292+ callback(1.0);
293+ }
294+
295+ Ok(())
296+}
297+
298+/// Downloads an episode's audio file
299+///
300+/// # Arguments
301+/// * `episode` - The episode to download
302+/// * `download_path` - The base download directory
303+/// * `progress_callback` - Optional callback for download progress
304+///
305+/// # Returns
306+/// * `Ok(PathBuf)` - The path where the file was saved
307+/// * `Err(DownloadError)` - If download fails
308+pub async fn download_episode(
309+ episode: &Episode,
310+ download_path: &Path,
311+ progress_callback: Option<ProgressCallback>,
312+) -> Result<std::path::PathBuf, DownloadError> {
313+ let save_path = episode.get_save_path(&download_path.to_path_buf());
314+
315+ info!(
316+ "Downloading episode '{}' from {} to {}",
317+ episode.title, episode.audio_url, save_path.display()
318+ );
319+
320+ download_file(&episode.audio_url, &save_path, progress_callback).await?;
321+
322+ Ok(save_path)
323+}
324+
325+/// Downloads multiple episodes
326+///
327+/// # Arguments
328+/// * `episodes` - The list of episodes to download
329+/// * `download_path` - The base download directory
330+/// * `progress_callbacks` - Map of episode IDs to progress callbacks
331+///
332+/// # Returns
333+/// * `Ok(Vec<PathBuf>)` - List of paths where files were saved
334+/// * `Err(DownloadError)` - If any download fails (stops at first error)
335+pub async fn download_episodes(
336+ episodes: &[Episode],
337+ download_path: &Path,
338+ progress_callbacks: &std::collections::HashMap<String, ProgressCallback>,
339+) -> Result<Vec<std::path::PathBuf>, DownloadError> {
340+ let mut saved_paths = Vec::with_capacity(episodes.len());
341+
342+ for episode in episodes {
343+ let callback = progress_callbacks.get(&episode.id).cloned();
344+ let path = download_episode(episode, download_path, callback).await?;
345+ saved_paths.push(path);
346+ }
347+
348+ Ok(saved_paths)
349+}
350+
351+/// Checks if a file needs to be downloaded (doesn't exist or is incomplete)
352+///
353+/// # Arguments
354+/// * `episode` - The episode to check
355+/// * `download_path` - The base download directory
356+///
357+/// # Returns
358+/// * `true` - If the episode needs to be downloaded
359+/// * `false` - If the episode is already downloaded
360+pub fn needs_download(episode: &Episode, download_path: &Path) -> bool {
361+ let save_path = episode.get_save_path(&download_path.to_path_buf());
362+
363+ // Check if file exists
364+ if !save_path.exists() {
365+ return true;
366+ }
367+
368+ // Check if file size matches
369+ if let Some(expected_size) = episode.file_size {
370+ if let Ok(metadata) = fs::metadata(&save_path) {
371+ if metadata.len() != expected_size {
372+ warn!(
373+ "File size mismatch for '{}': expected {}, found {}",
374+ episode.title, expected_size, metadata.len()
375+ );
376+ return true;
377+ }
378+ }
379+ }
380+
381+ false
382+}
383+
384+/// Removes a downloaded episode file
385+///
386+/// # Arguments
387+/// * `episode` - The episode to remove
388+/// * `download_path` - The base download directory
389+///
390+/// # Returns
391+/// * `Ok(())` - If removal succeeds
392+/// * `Err(DownloadError)` - If removal fails
393+pub fn remove_downloaded_episode(episode: &Episode, download_path: &Path) -> Result<(), DownloadError> {
394+ let save_path = episode.get_save_path(&download_path.to_path_buf());
395+
396+ if save_path.exists() {
397+ fs::remove_file(&save_path)
398+ .map_err(|e| DownloadError::WriteError(format!("Failed to remove {}: {}", save_path.display(), e)))?;
399+ info!("Removed downloaded episode: {}", episode.title);
400+ }
401+
402+ Ok(())
403+}
404+
405+/// Gets the download directory for a feed
406+///
407+/// # Arguments
408+/// * `feed_download_path` - The feed's download path
409+///
410+/// # Returns
411+/// * `PathBuf` - The download directory path
412+pub fn get_download_dir(feed_download_path: &Path) -> PathBuf {
413+ feed_download_path.to_path_buf()
414+}
415+
416+#[cfg(test)]
417+mod tests {
418+ use super::*;
419+ use std::io::Read;
420+ use tempfile::NamedTempFile;
421+
422+ #[test]
423+ fn test_download_client_new() {
424+ let client = DownloadClient::new();
425+ assert!(!client.client.to_string().is_empty());
426+ }
427+
428+ #[test]
429+ fn test_download_error_display() {
430+ let err = DownloadError::HttpError("Connection refused".to_string());
431+ assert!(err.to_string().contains("Connection refused"));
432+
433+ let err = DownloadError::Timeout(60);
434+ assert!(err.to_string().contains("60 seconds"));
435+
436+ let err = DownloadError::FileExists("/path/to/file.mp3".to_string());
437+ assert!(err.to_string().contains("/path/to/file.mp3"));
438+ }
439+
440+ #[test]
441+ fn test_needs_download_file_exists() {
442+ let temp_file = NamedTempFile::new().unwrap();
443+ let path = temp_file.path().to_path_buf();
444+
445+ let episode = Episode {
446+ id: "test-1".to_string(),
447+ title: "Test Episode".to_string(),
448+ description: None,
449+ pub_date: Utc::now(),
450+ audio_url: "https://example.com/episode.mp3".to_string(),
451+ audio_filename: "episode.mp3".to_string(),
452+ downloaded: false,
453+ file_size: Some(1024),
454+ mime_type: None,
455+ duration_seconds: None,
456+ };
457+
458+ // File exists, size should match
459+ assert!(!needs_download(&episode, &path.parent().unwrap()));
460+ }
461+
462+ #[test]
463+ fn test_needs_download_file_missing() {
464+ let path = Path::new("/nonexistent/directory");
465+
466+ let episode = Episode {
467+ id: "test-1".to_string(),
468+ title: "Test Episode".to_string(),
469+ description: None,
470+ pub_date: Utc::now(),
471+ audio_url: "https://example.com/episode.mp3".to_string(),
472+ audio_filename: "episode.mp3".to_string(),
473+ downloaded: false,
474+ file_size: Some(1024),
475+ mime_type: None,
476+ duration_seconds: None,
477+ };
478+
479+ // File doesn't exist
480+ assert!(needs_download(&episode, path));
481+ }
482+
483+ #[test]
484+ fn test_get_download_dir() {
485+ let path = Path::new("/downloads/podcasts");
486+ let dir = get_download_dir(path);
487+ assert_eq!(dir, PathBuf::from("/downloads/podcasts"));
488+ }
489+}
new file mode 100644
@@ -0,0 +1,489 @@
1+//! Downloader module
2+//!
3+//! This module handles downloading podcast episodes from URLs.
4+
5+use crate::config::episode::Episode;
6+use log::{debug, error, info, warn};
7+use reqwest::Client;
8+use std::fs::{self, File};
9+use std::io::{self, Write};
10+use std::path::Path;
11+use std::time::Duration;
12+use thiserror::Error;
13+
14+/// Maximum number of retries for downloading a file
15+const MAX_DOWNLOAD_RETRIES: u32 = 3;
16+
17+/// Timeout for download requests (in seconds)
18+const DOWNLOAD_TIMEOUT_SECS: u64 = 60;
19+
20+/// Buffer size for downloading (in bytes)
21+const DOWNLOAD_BUFFER_SIZE: usize = 8192;
22+
23+/// Error type for download operations
24+#[derive(Debug, Error)]
25+pub enum DownloadError {
26+ /// HTTP request failed
27+ #[error("HTTP request failed: {0}")]
28+ HttpError(String),
29+
30+ /// Request timeout
31+ #[error("Request timeout after {0} seconds")]
32+ Timeout(u64),
33+
34+ /// Invalid URL
35+ #[error("Invalid URL: {0}")]
36+ InvalidUrl(String),
37+
38+ /// Failed to create parent directory
39+ #[error("Failed to create directory: {0}")]
40+ DirectoryError(String),
41+
42+ /// Failed to create file
43+ #[error("Failed to create file: {0}")]
44+ FileCreationError(String),
45+
46+ /// Failed to write to file
47+ #[error("Failed to write to file: {0}")]
48+ WriteError(String),
49+
50+ /// Network connection error
51+ #[error("Network error: {0}")]
52+ NetworkError(String),
53+
54+ /// File already exists
55+ #[error("File already exists: {0}")]
56+ FileExists(String),
57+
58+ /// Insufficient disk space
59+ #[error("Insufficient disk space")]
60+ DiskFull,
61+
62+ /// Content length mismatch
63+ #[error("Content length mismatch")]
64+ ContentLengthMismatch,
65+}
66+
67+/// Type alias for progress callback
68+///
69+/// The callback receives a value between 0.0 and 1.0 representing the download progress.
70+pub type ProgressCallback = Box<dyn Fn(f32) + Send + Sync>;
71+
72+/// HTTP client with custom configuration for downloading
73+pub struct DownloadClient {
74+ client: Client,
75+}
76+
77+impl Default for DownloadClient {
78+ fn default() -> Self {
79+ Self::new()
80+ }
81+}
82+
83+impl DownloadClient {
84+ /// Creates a new DownloadClient with custom configuration
85+ pub fn new() -> Self {
86+ let client = Client::builder()
87+ .timeout(Duration::from_secs(DOWNLOAD_TIMEOUT_SECS))
88+ .redirect(reqwest::redirect::Policy::limited(5))
89+ .user_agent("RSS-Podcast-Downloader/1.0")
90+ .build()
91+ .expect("Failed to create HTTP client");
92+
93+ Self { client }
94+ }
95+
96+ /// Creates a client with custom timeout
97+ pub fn with_timeout(timeout_secs: u64) -> Self {
98+ let client = Client::builder()
99+ .timeout(Duration::from_secs(timeout_secs))
100+ .redirect(reqwest::redirect::Policy::limited(5))
101+ .user_agent("RSS-Podcast-Downloader/1.0")
102+ .build()
103+ .expect("Failed to create HTTP client");
104+
105+ Self { client }
106+ }
107+}
108+
109+/// Downloads a file from a URL to a destination path
110+///
111+/// # Arguments
112+/// * `url` - The URL to download from
113+/// * `dest` - The destination path
114+/// * `progress_callback` - Optional callback for download progress (0.0-1.0)
115+///
116+/// # Returns
117+/// * `Ok(())` - If download succeeds
118+/// * `Err(DownloadError)` - If download fails
119+pub async fn download_file(
120+ url: &str,
121+ dest: &Path,
122+ progress_callback: Option<ProgressCallback>,
123+) -> Result<(), DownloadError> {
124+ download_file_with_client(url, dest, progress_callback, &DownloadClient::default(), MAX_DOWNLOAD_RETRIES).await
125+}
126+
127+/// Downloads a file using a custom client
128+///
129+/// # Arguments
130+/// * `url` - The URL to download from
131+/// * `dest` - The destination path
132+/// * `progress_callback` - Optional callback for download progress
133+/// * `client` - Custom HTTP client
134+/// * `retries` - Number of retries on failure
135+///
136+/// # Returns
137+/// * `Ok(())` - If download succeeds
138+/// * `Err(DownloadError)` - If download fails
139+pub async fn download_file_with_client(
140+ url: &str,
141+ dest: &Path,
142+ progress_callback: Option<ProgressCallback>,
143+ client: &DownloadClient,
144+ retries: u32,
145+) -> Result<(), DownloadError> {
146+ // Validate URL
147+ if url.is_empty() {
148+ return Err(DownloadError::InvalidUrl("URL cannot be empty".to_string()));
149+ }
150+
151+ if !url.starts_with("http://") && !url.starts_with("https://") {
152+ return Err(DownloadError::InvalidUrl(
153+ "URL must start with http:// or https://".to_string(),
154+ ));
155+ }
156+
157+ // Check if file already exists
158+ if dest.exists() {
159+ // Check if we should overwrite
160+ // For now, return error - we'll handle overwrite logic in the caller
161+ return Err(DownloadError::FileExists(dest.display().to_string()));
162+ }
163+
164+ // Create parent directories
165+ if let Some(parent) = dest.parent() {
166+ if !parent.exists() {
167+ fs::create_dir_all(parent)
168+ .map_err(|e| DownloadError::DirectoryError(format!("{}: {}", parent.display(), e)))?;
169+ }
170+ }
171+
172+ let mut last_error: Option<DownloadError> = None;
173+
174+ for attempt in 0..=retries {
175+ if attempt > 0 {
176+ debug!(
177+ "Retry {} for {} (attempt {}/{})",
178+ url, attempt, retries
179+ );
180+ // Add delay between retries
181+ tokio::time::sleep(Duration::from_secs(1 << attempt.min(5))).await;
182+ }
183+
184+ match download_file_once(url, dest, progress_callback.as_deref(), client).await {
185+ Ok(_) => {
186+ info!("Successfully downloaded file from {} to {}", url, dest.display());
187+ return Ok(());
188+ }
189+ Err(e) => {
190+ last_error = Some(e);
191+ warn!(
192+ "Failed to download from {} (attempt {}/{}): {}",
193+ url, attempt, retries, last_error.as_ref().unwrap()
194+ );
195+ }
196+ }
197+ }
198+
199+ Err(last_error.unwrap_or(DownloadError::HttpError("Unknown error".to_string())))
200+}
201+
202+/// Single attempt to download a file
203+async fn download_file_once(
204+ url: &str,
205+ dest: &Path,
206+ progress_callback: Option<&ProgressCallback>,
207+ client: &DownloadClient,
208+) -> Result<(), DownloadError> {
209+ // Send HEAD request first to get content length
210+ let head_response = match client.client.head(url).send().await {
211+ Ok(resp) => resp,
212+ Err(e) => {
213+ if e.is_timeout() {
214+ return Err(DownloadError::Timeout(DOWNLOAD_TIMEOUT_SECS));
215+ }
216+ return Err(DownloadError::HttpError(e.to_string()));
217+ }
218+ };
219+
220+ // Get content length if available
221+ let content_length = head_response
222+ .content_length()
223+ .map(|len| len as u64);
224+
225+ // Now send GET request with streaming
226+ let mut response = match client.client.get(url).send().await {
227+ Ok(resp) => resp,
228+ Err(e) => {
229+ if e.is_timeout() {
230+ return Err(DownloadError::Timeout(DOWNLOAD_TIMEOUT_SECS));
231+ }
232+ return Err(DownloadError::HttpError(e.to_string()));
233+ }
234+ };
235+
236+ // Check status code
237+ if !response.status().is_success() {
238+ let status = response.status();
239+ if status.is_client_error() || status.is_server_error() {
240+ return Err(DownloadError::HttpError(format!(
241+ "HTTP {}: {}",
242+ status.as_u16(),
243+ status.canonical_reason().unwrap_or("Unknown error")
244+ )));
245+ }
246+ }
247+
248+ // Create the file
249+ let mut file = File::create(dest)
250+ .map_err(|e| DownloadError::FileCreationError(format!("{}: {}", dest.display(), e)))?;
251+
252+ // Stream the response body
253+ let mut stream = response.bytes_stream();
254+ let mut bytes_downloaded: u64 = 0;
255+
256+ while let Some(chunk) = stream.next().await {
257+ let chunk = chunk.map_err(|e| DownloadError::HttpError(e.to_string()))?;
258+
259+ file.write_all(&chunk)
260+ .map_err(|e| DownloadError::WriteError(format!("{}: {}", dest.display(), e)))?;
261+
262+ bytes_downloaded += chunk.len() as u64;
263+
264+ // Update progress
265+ if let Some(callback) = progress_callback {
266+ let progress = if let Some(total) = content_length {
267+ (bytes_downloaded as f32 / total as f32).min(1.0)
268+ } else {
269+ // If we don't know the total size, we can't calculate progress
270+ // Just report 0.0 until the end
271+ if stream.size_hint().map_or(0, |(_, upper)| upper) > 0 {
272+ 0.0
273+ } else {
274+ // If this is the last chunk (stream is exhausted)
275+ // We'll check this differently
276+ 0.0
277+ }
278+ };
279+
280+ // Call the progress callback
281+ callback(progress);
282+ }
283+
284+ debug!(
285+ "Downloaded {} bytes ({} total)",
286+ chunk.len(), bytes_downloaded
287+ );
288+ }
289+
290+ // Ensure progress reaches 1.0 at the end
291+ if let Some(callback) = progress_callback {
292+ callback(1.0);
293+ }
294+
295+ Ok(())
296+}
297+
298+/// Downloads an episode's audio file
299+///
300+/// # Arguments
301+/// * `episode` - The episode to download
302+/// * `download_path` - The base download directory
303+/// * `progress_callback` - Optional callback for download progress
304+///
305+/// # Returns
306+/// * `Ok(PathBuf)` - The path where the file was saved
307+/// * `Err(DownloadError)` - If download fails
308+pub async fn download_episode(
309+ episode: &Episode,
310+ download_path: &Path,
311+ progress_callback: Option<ProgressCallback>,
312+) -> Result<std::path::PathBuf, DownloadError> {
313+ let save_path = episode.get_save_path(&download_path.to_path_buf());
314+
315+ info!(
316+ "Downloading episode '{}' from {} to {}",
317+ episode.title, episode.audio_url, save_path.display()
318+ );
319+
320+ download_file(&episode.audio_url, &save_path, progress_callback).await?;
321+
322+ Ok(save_path)
323+}
324+
325+/// Downloads multiple episodes
326+///
327+/// # Arguments
328+/// * `episodes` - The list of episodes to download
329+/// * `download_path` - The base download directory
330+/// * `progress_callbacks` - Map of episode IDs to progress callbacks
331+///
332+/// # Returns
333+/// * `Ok(Vec<PathBuf>)` - List of paths where files were saved
334+/// * `Err(DownloadError)` - If any download fails (stops at first error)
335+pub async fn download_episodes(
336+ episodes: &[Episode],
337+ download_path: &Path,
338+ progress_callbacks: &std::collections::HashMap<String, ProgressCallback>,
339+) -> Result<Vec<std::path::PathBuf>, DownloadError> {
340+ let mut saved_paths = Vec::with_capacity(episodes.len());
341+
342+ for episode in episodes {
343+ let callback = progress_callbacks.get(&episode.id).cloned();
344+ let path = download_episode(episode, download_path, callback).await?;
345+ saved_paths.push(path);
346+ }
347+
348+ Ok(saved_paths)
349+}
350+
351+/// Checks if a file needs to be downloaded (doesn't exist or is incomplete)
352+///
353+/// # Arguments
354+/// * `episode` - The episode to check
355+/// * `download_path` - The base download directory
356+///
357+/// # Returns
358+/// * `true` - If the episode needs to be downloaded
359+/// * `false` - If the episode is already downloaded
360+pub fn needs_download(episode: &Episode, download_path: &Path) -> bool {
361+ let save_path = episode.get_save_path(&download_path.to_path_buf());
362+
363+ // Check if file exists
364+ if !save_path.exists() {
365+ return true;
366+ }
367+
368+ // Check if file size matches
369+ if let Some(expected_size) = episode.file_size {
370+ if let Ok(metadata) = fs::metadata(&save_path) {
371+ if metadata.len() != expected_size {
372+ warn!(
373+ "File size mismatch for '{}': expected {}, found {}",
374+ episode.title, expected_size, metadata.len()
375+ );
376+ return true;
377+ }
378+ }
379+ }
380+
381+ false
382+}
383+
384+/// Removes a downloaded episode file
385+///
386+/// # Arguments
387+/// * `episode` - The episode to remove
388+/// * `download_path` - The base download directory
389+///
390+/// # Returns
391+/// * `Ok(())` - If removal succeeds
392+/// * `Err(DownloadError)` - If removal fails
393+pub fn remove_downloaded_episode(episode: &Episode, download_path: &Path) -> Result<(), DownloadError> {
394+ let save_path = episode.get_save_path(&download_path.to_path_buf());
395+
396+ if save_path.exists() {
397+ fs::remove_file(&save_path)
398+ .map_err(|e| DownloadError::WriteError(format!("Failed to remove {}: {}", save_path.display(), e)))?;
399+ info!("Removed downloaded episode: {}", episode.title);
400+ }
401+
402+ Ok(())
403+}
404+
405+/// Gets the download directory for a feed
406+///
407+/// # Arguments
408+/// * `feed_download_path` - The feed's download path
409+///
410+/// # Returns
411+/// * `PathBuf` - The download directory path
412+pub fn get_download_dir(feed_download_path: &Path) -> PathBuf {
413+ feed_download_path.to_path_buf()
414+}
415+
416+#[cfg(test)]
417+mod tests {
418+ use super::*;
419+ use std::io::Read;
420+ use tempfile::NamedTempFile;
421+
422+ #[test]
423+ fn test_download_client_new() {
424+ let client = DownloadClient::new();
425+ assert!(!client.client.to_string().is_empty());
426+ }
427+
428+ #[test]
429+ fn test_download_error_display() {
430+ let err = DownloadError::HttpError("Connection refused".to_string());
431+ assert!(err.to_string().contains("Connection refused"));
432+
433+ let err = DownloadError::Timeout(60);
434+ assert!(err.to_string().contains("60 seconds"));
435+
436+ let err = DownloadError::FileExists("/path/to/file.mp3".to_string());
437+ assert!(err.to_string().contains("/path/to/file.mp3"));
438+ }
439+
440+ #[test]
441+ fn test_needs_download_file_exists() {
442+ let temp_file = NamedTempFile::new().unwrap();
443+ let path = temp_file.path().to_path_buf();
444+
445+ let episode = Episode {
446+ id: "test-1".to_string(),
447+ title: "Test Episode".to_string(),
448+ description: None,
449+ pub_date: Utc::now(),
450+ audio_url: "https://example.com/episode.mp3".to_string(),
451+ audio_filename: "episode.mp3".to_string(),
452+ downloaded: false,
453+ file_size: Some(1024),
454+ mime_type: None,
455+ duration_seconds: None,
456+ };
457+
458+ // File exists, size should match
459+ assert!(!needs_download(&episode, &path.parent().unwrap()));
460+ }
461+
462+ #[test]
463+ fn test_needs_download_file_missing() {
464+ let path = Path::new("/nonexistent/directory");
465+
466+ let episode = Episode {
467+ id: "test-1".to_string(),
468+ title: "Test Episode".to_string(),
469+ description: None,
470+ pub_date: Utc::now(),
471+ audio_url: "https://example.com/episode.mp3".to_string(),
472+ audio_filename: "episode.mp3".to_string(),
473+ downloaded: false,
474+ file_size: Some(1024),
475+ mime_type: None,
476+ duration_seconds: None,
477+ };
478+
479+ // File doesn't exist
480+ assert!(needs_download(&episode, path));
481+ }
482+
483+ #[test]
484+ fn test_get_download_dir() {
485+ let path = Path::new("/downloads/podcasts");
486+ let dir = get_download_dir(path);
487+ assert_eq!(dir, PathBuf::from("/downloads/podcasts"));
488+ }
489+}
added src/rss/episode_extractor.rs +381 -0
new file mode 100644
@@ -0,0 +1,381 @@
1+//! Episode Extractor module
2+//!
3+//! This module extracts podcast episodes from RSS/Atom feeds.
4+
5+use crate::config::episode::Episode;
6+use chrono::{DateTime, Utc};
7+use log::{debug, info, warn};
8+use rss::{Channel, Enclosure, Item};
9+use std::collections::HashSet;
10+use thiserror::Error;
11+
12+/// Error type for episode extraction
13+#[derive(Debug, Error)]
14+pub enum ExtractionError {
15+ /// No items found in the feed
16+ #[error("No items found in the feed")]
17+ NoItemsFound,
18+
19+ /// No valid audio episodes found
20+ #[error("No valid audio episodes found in the feed")]
21+ NoAudioEpisodes,
22+
23+ /// Invalid date format in feed
24+ #[error("Invalid date format in feed item: {0}")]
25+ InvalidDateFormat(String),
26+
27+ /// Missing required field in feed item
28+ #[error("Missing required field in feed item: {0}")]
29+ MissingField(String),
30+}
31+
32+/// Extracts podcast episodes from an RSS Channel
33+///
34+/// This function processes the items in a Channel and converts them to Episode structs.
35+/// It filters out items that don't have valid audio enclosures.
36+///
37+/// # Arguments
38+/// * `channel` - The RSS Channel to extract episodes from
39+///
40+/// # Returns
41+/// * `Ok(Vec<Episode>)` - List of extracted episodes, sorted by publication date (newest first)
42+/// * `Err(ExtractionError)` - Error if extraction fails
43+pub fn extract_episodes(channel: &Channel) -> Result<Vec<Episode>, ExtractionError> {
44+ info!(
45+ "Extracting episodes from feed: {} ({} items)",
46+ channel.title().unwrap_or("Unknown"),
47+ channel.items().len()
48+ );
49+
50+ let mut episodes: Vec<Episode> = Vec::new();
51+
52+ for item in channel.items() {
53+ match extract_episode_from_item(item, channel) {
54+ Ok(episode) => {
55+ episodes.push(episode);
56+ }
57+ Err(e) => {
58+ debug!("Skipping feed item due to error: {}", e);
59+ }
60+ }
61+ }
62+
63+ if episodes.is_empty() {
64+ // Check if there were any items at all
65+ if channel.items().is_empty() {
66+ return Err(ExtractionError::NoItemsFound);
67+ }
68+ // There were items but no valid audio episodes
69+ return Err(ExtractionError::NoAudioEpisodes);
70+ }
71+
72+ // Sort by publication date (newest first)
73+ episodes.sort_by(|a, b| b.pub_date.cmp(&a.pub_date));
74+
75+ info!("Extracted {} episodes", episodes.len());
76+ Ok(episodes)
77+}
78+
79+/// Extracts a single episode from an RSS Item
80+///
81+/// # Arguments
82+/// * `item` - The RSS Item to extract from
83+/// * `channel` - The parent Channel (for fallback data)
84+///
85+/// # Returns
86+/// * `Ok(Episode)` - The extracted episode
87+/// * `Err(ExtractionError)` - Error if extraction fails
88+fn extract_episode_from_item(item: &Item, channel: &Channel) -> Result<Episode, ExtractionError> {
89+ // Get or generate episode ID
90+ let id = item
91+ .guid()
92+ .and_then(|g| g.value())
93+ .map(|s| s.to_string())
94+ .or_else(|| {
95+ item.link()
96+ .map(|link| link.to_string())
97+ .or_else(|| Some(format!("item-{}", item.title().unwrap_or("unknown"))))
98+ })
99+ .unwrap_or_else(|| uuid::Uuid::new_v4().to_string());
100+
101+ // Get episode title (fallback to channel title)
102+ let title = item
103+ .title()
104+ .map(|s| s.to_string())
105+ .unwrap_or_else(|| channel.title().unwrap_or("Unknown Episode").to_string());
106+
107+ // Get description
108+ let description = item
109+ .description()
110+ .or_else(|| item.content().and_then(|c| c.value()))
111+ .or_else(|| channel.description().map(|d| d.to_string()))
112+ .map(|s| s.to_string());
113+
114+ // Get publication date
115+ let pub_date = match item.pub_date() {
116+ Some(date_str) => {
117+ // Try to parse various date formats
118+ parse_rss_date(date_str).unwrap_or_else(|_| Utc::now())
119+ }
120+ None => {
121+ // Fallback to channel pub_date or current time
122+ channel
123+ .pub_date()
124+ .and_then(|d| parse_rss_date(d).ok())
125+ .unwrap_or_else(|| Utc::now())
126+ }
127+ };
128+
129+ // Find audio enclosure
130+ let (audio_url, audio_filename, mime_type, file_size) = find_audio_enclosure(item)?;
131+
132+ // Create episode
133+ Ok(Episode {
134+ id,
135+ title,
136+ description,
137+ pub_date,
138+ audio_url,
139+ audio_filename,
140+ downloaded: false,
141+ file_size,
142+ mime_type,
143+ duration_seconds: None, // Will be extracted from metadata later
144+ })
145+}
146+
147+/// Finds the first valid audio enclosure in an RSS Item
148+///
149+/// # Arguments
150+/// * `item` - The RSS Item to search in
151+///
152+/// # Returns
153+/// * `Some((url, filename, mime_type, file_size))` - The audio enclosure details
154+/// * `None` - If no valid audio enclosure is found
155+fn find_audio_enclosure(item: &Item) -> Option<(String, String, Option<String>, Option<u64>)> {
156+ // List of audio MIME types to look for
157+ let audio_mime_types = [
158+ "audio/mpeg",
159+ "audio/mp3",
160+ "audio/m4a",
161+ "audio/aac",
162+ "audio/wav",
163+ "audio/wave",
164+ "audio/ogg",
165+ "audio/opus",
166+ "audio/flac",
167+ "audio/x-m4a",
168+ "audio/mp4",
169+ ];
170+
171+ // List of audio file extensions to look for
172+ let audio_extensions = [
173+ ".mp3", ".m4a", ".aac", ".wav", ".ogg", ".opus", ".flac", ".mp4",
174+ ];
175+
176+ for enclosure in item.enclosures() {
177+ let url = enclosure.url().to_string();
178+ let mime_type = enclosure.mime_type().map(|s| s.to_string());
179+ let length = enclosure.length();
180+
181+ // Check by MIME type
182+ if let Some(ref mime) = mime_type {
183+ let mime_lower = mime.to_lowercase();
184+ if audio_mime_types.iter().any(|&m| mime_lower == m) {
185+ let filename = extract_filename_from_url(&url);
186+ return Some((url, filename, mime_type, length));
187+ }
188+ }
189+
190+ // Check by URL extension
191+ let url_lower = url.to_lowercase();
192+ if audio_extensions.iter().any(|&ext| url_lower.ends_with(ext)) {
193+ let filename = extract_filename_from_url(&url);
194+ return Some((url, filename, mime_type, length));
195+ }
196+ }
197+
198+ None
199+}
200+
201+/// Extracts filename from a URL
202+fn extract_filename_from_url(url: &str) -> String {
203+ let path = std::path::Path::new(url);
204+ path.file_name()
205+ .and_then(|os_str| os_str.to_str())
206+ .map(|s| s.to_string())
207+ .unwrap_or_else(|| {
208+ // Generate a filename from the URL hash
209+ let hash = md5::compute(url.as_bytes());
210+ format!("{:x}.mp3", hash)
211+ })
212+}
213+
214+/// Parses an RSS date string into a DateTime
215+///
216+/// RSS dates can be in various formats:
217+/// - RFC 2822: "Wed, 21 Oct 2015 07:28:00 GMT"
218+/// - RFC 822: "Wed, 21 Oct 2015 07:28:00 +0000"
219+/// - ISO 8601: "2015-10-21T07:28:00Z"
220+///
221+/// # Arguments
222+/// * `date_str` - The date string to parse
223+///
224+/// # Returns
225+/// * `Ok(DateTime<Utc>)` - The parsed date
226+/// * `Err(String)` - Error message if parsing fails
227+fn parse_rss_date(date_str: &str) -> Result<DateTime<Utc>, String> {
228+ // Try RFC 2822 first (most common in RSS)
229+ if let Ok(date) = chrono::DateTime::parse_from_rfc2822(date_str) {
230+ return Ok(date.with_timezone(&Utc));
231+ }
232+
233+ // Try RFC 822
234+ if let Ok(date) = chrono::DateTime::parse_from_rfc822(date_str) {
235+ return Ok(date.with_timezone(&Utc));
236+ }
237+
238+ // Try ISO 8601
239+ if let Ok(date) = chrono::DateTime::parse_from_rfc3339(date_str) {
240+ return Ok(date.with_timezone(&Utc));
241+ }
242+
243+ // Try various other formats
244+ // Format: "Wed, 21 Oct 2015 07:28:00 GMT"
245+ if let Ok(date) = chrono::NaiveDateTime::parse_from_str(date_str, "%a, %d %b %Y %H:%M:%S %Z") {
246+ return Ok(DateTime::<Utc>::from_utc(date, Utc));
247+ }
248+
249+ // Format: "21 Oct 2015 07:28:00 +0000"
250+ if let Ok(date) = chrono::NaiveDateTime::parse_from_str(date_str, "%d %b %Y %H:%M:%S %z") {
251+ return Ok(DateTime::<Utc>::from_utc(date, Utc));
252+ }
253+
254+ // Try to use chrono's flexible parser
255+ if let Ok(date) = chrono::DateTime::parse_from_str(date_str, "%a, %d %b %Y %H:%M:%S %z") {
256+ return Ok(date.with_timezone(&Utc));
257+ }
258+
259+ // As a last resort, try to parse using diligent-date-parser
260+ if let Ok(parsed) = diligent_date_parser::parse_date(date_str) {
261+ if let Some(datetime) = parsed.datetime {
262+ return Ok(datetime);
263+ }
264+ }
265+
266+ Err(format!("Failed to parse date: {}", date_str))
267+}
268+
269+/// Extracts episodes from an RSS feed and filters by date
270+///
271+/// Only returns episodes published after the given date.
272+///
273+/// # Arguments
274+/// * `channel` - The RSS Channel to extract from
275+/// * `since_date` - Only include episodes published after this date
276+///
277+/// # Returns
278+/// * `Ok(Vec<Episode>)` - Filtered list of episodes
279+/// * `Err(ExtractionError)` - Error if extraction fails
280+pub fn extract_episodes_since(
281+ channel: &Channel,
282+ since_date: DateTime<Utc>,
283+) -> Result<Vec<Episode>, ExtractionError> {
284+ let all_episodes = extract_episodes(channel)?;
285+ let filtered: Vec<Episode> = all_episodes
286+ .into_iter()
287+ .filter(|e| e.pub_date > since_date)
288+ .collect();
289+
290+ if filtered.is_empty() {
291+ info!("No new episodes found since {}", since_date);
292+ }
293+
294+ Ok(filtered)
295+}
296+
297+/// Extracts episodes from an RSS feed and returns only new ones
298+///
299+/// This function compares the episodes with a set of already downloaded episode IDs.
300+///
301+/// # Arguments
302+/// * `channel` - The RSS Channel to extract from
303+/// * `downloaded_ids` - Set of already downloaded episode IDs
304+///
305+/// # Returns
306+/// * `Ok(Vec<Episode>)` - List of new episodes
307+/// * `Err(ExtractionError)` - Error if extraction fails
308+pub fn extract_new_episodes(
309+ channel: &Channel,
310+ downloaded_ids: &HashSet<String>,
311+) -> Result<Vec<Episode>, ExtractionError> {
312+ let all_episodes = extract_episodes(channel)?;
313+ let new_episodes: Vec<Episode> = all_episodes
314+ .into_iter()
315+ .filter(|e| !downloaded_ids.contains(&e.id))
316+ .collect();
317+
318+ if new_episodes.is_empty() {
319+ info!("No new episodes found");
320+ } else {
321+ info!("Found {} new episodes", new_episodes.len());
322+ }
323+
324+ Ok(new_episodes)
325+}
326+
327+#[cfg(test)]
328+mod tests {
329+ use super::*;
330+ use chrono::TimeZone;
331+
332+ #[test]
333+ fn test_parse_rss_date_rfc2822() {
334+ let date_str = "Wed, 21 Oct 2015 07:28:00 GMT";
335+ let result = parse_rss_date(date_str).unwrap();
336+ assert_eq!(result.year(), 2015);
337+ assert_eq!(result.month(), 10);
338+ assert_eq!(result.day(), 21);
339+ }
340+
341+ #[test]
342+ fn test_parse_rss_date_rfc3339() {
343+ let date_str = "2015-10-21T07:28:00Z";
344+ let result = parse_rss_date(date_str).unwrap();
345+ assert_eq!(result.year(), 2015);
346+ assert_eq!(result.month(), 10);
347+ assert_eq!(result.day(), 21);
348+ }
349+
350+ #[test]
351+ fn test_extract_filename_from_url() {
352+ assert_eq!(
353+ extract_filename_from_url("https://example.com/episode.mp3"),
354+ "episode.mp3"
355+ );
356+ assert_eq!(
357+ extract_filename_from_url("https://example.com/path/to/episode.mp3"),
358+ "episode.mp3"
359+ );
360+ assert_eq!(
361+ extract_filename_from_url("https://example.com/episode"),
362+ "episode"
363+ );
364+ }
365+
366+ #[test]
367+ fn test_extract_episodes_empty_feed() {
368+ let channel = Channel::default();
369+ let result = extract_episodes(&channel);
370+ assert!(result.is_err());
371+ }
372+
373+ #[test]
374+ fn test_extraction_error_display() {
375+ let err = ExtractionError::NoItemsFound;
376+ assert!(err.to_string().contains("No items found"));
377+
378+ let err = ExtractionError::NoAudioEpisodes;
379+ assert!(err.to_string().contains("No valid audio episodes"));
380+ }
381+}
new file mode 100644
@@ -0,0 +1,381 @@
1+//! Episode Extractor module
2+//!
3+//! This module extracts podcast episodes from RSS/Atom feeds.
4+
5+use crate::config::episode::Episode;
6+use chrono::{DateTime, Utc};
7+use log::{debug, info, warn};
8+use rss::{Channel, Enclosure, Item};
9+use std::collections::HashSet;
10+use thiserror::Error;
11+
12+/// Error type for episode extraction
13+#[derive(Debug, Error)]
14+pub enum ExtractionError {
15+ /// No items found in the feed
16+ #[error("No items found in the feed")]
17+ NoItemsFound,
18+
19+ /// No valid audio episodes found
20+ #[error("No valid audio episodes found in the feed")]
21+ NoAudioEpisodes,
22+
23+ /// Invalid date format in feed
24+ #[error("Invalid date format in feed item: {0}")]
25+ InvalidDateFormat(String),
26+
27+ /// Missing required field in feed item
28+ #[error("Missing required field in feed item: {0}")]
29+ MissingField(String),
30+}
31+
32+/// Extracts podcast episodes from an RSS Channel
33+///
34+/// This function processes the items in a Channel and converts them to Episode structs.
35+/// It filters out items that don't have valid audio enclosures.
36+///
37+/// # Arguments
38+/// * `channel` - The RSS Channel to extract episodes from
39+///
40+/// # Returns
41+/// * `Ok(Vec<Episode>)` - List of extracted episodes, sorted by publication date (newest first)
42+/// * `Err(ExtractionError)` - Error if extraction fails
43+pub fn extract_episodes(channel: &Channel) -> Result<Vec<Episode>, ExtractionError> {
44+ info!(
45+ "Extracting episodes from feed: {} ({} items)",
46+ channel.title().unwrap_or("Unknown"),
47+ channel.items().len()
48+ );
49+
50+ let mut episodes: Vec<Episode> = Vec::new();
51+
52+ for item in channel.items() {
53+ match extract_episode_from_item(item, channel) {
54+ Ok(episode) => {
55+ episodes.push(episode);
56+ }
57+ Err(e) => {
58+ debug!("Skipping feed item due to error: {}", e);
59+ }
60+ }
61+ }
62+
63+ if episodes.is_empty() {
64+ // Check if there were any items at all
65+ if channel.items().is_empty() {
66+ return Err(ExtractionError::NoItemsFound);
67+ }
68+ // There were items but no valid audio episodes
69+ return Err(ExtractionError::NoAudioEpisodes);
70+ }
71+
72+ // Sort by publication date (newest first)
73+ episodes.sort_by(|a, b| b.pub_date.cmp(&a.pub_date));
74+
75+ info!("Extracted {} episodes", episodes.len());
76+ Ok(episodes)
77+}
78+
79+/// Extracts a single episode from an RSS Item
80+///
81+/// # Arguments
82+/// * `item` - The RSS Item to extract from
83+/// * `channel` - The parent Channel (for fallback data)
84+///
85+/// # Returns
86+/// * `Ok(Episode)` - The extracted episode
87+/// * `Err(ExtractionError)` - Error if extraction fails
88+fn extract_episode_from_item(item: &Item, channel: &Channel) -> Result<Episode, ExtractionError> {
89+ // Get or generate episode ID
90+ let id = item
91+ .guid()
92+ .and_then(|g| g.value())
93+ .map(|s| s.to_string())
94+ .or_else(|| {
95+ item.link()
96+ .map(|link| link.to_string())
97+ .or_else(|| Some(format!("item-{}", item.title().unwrap_or("unknown"))))
98+ })
99+ .unwrap_or_else(|| uuid::Uuid::new_v4().to_string());
100+
101+ // Get episode title (fallback to channel title)
102+ let title = item
103+ .title()
104+ .map(|s| s.to_string())
105+ .unwrap_or_else(|| channel.title().unwrap_or("Unknown Episode").to_string());
106+
107+ // Get description
108+ let description = item
109+ .description()
110+ .or_else(|| item.content().and_then(|c| c.value()))
111+ .or_else(|| channel.description().map(|d| d.to_string()))
112+ .map(|s| s.to_string());
113+
114+ // Get publication date
115+ let pub_date = match item.pub_date() {
116+ Some(date_str) => {
117+ // Try to parse various date formats
118+ parse_rss_date(date_str).unwrap_or_else(|_| Utc::now())
119+ }
120+ None => {
121+ // Fallback to channel pub_date or current time
122+ channel
123+ .pub_date()
124+ .and_then(|d| parse_rss_date(d).ok())
125+ .unwrap_or_else(|| Utc::now())
126+ }
127+ };
128+
129+ // Find audio enclosure
130+ let (audio_url, audio_filename, mime_type, file_size) = find_audio_enclosure(item)?;
131+
132+ // Create episode
133+ Ok(Episode {
134+ id,
135+ title,
136+ description,
137+ pub_date,
138+ audio_url,
139+ audio_filename,
140+ downloaded: false,
141+ file_size,
142+ mime_type,
143+ duration_seconds: None, // Will be extracted from metadata later
144+ })
145+}
146+
147+/// Finds the first valid audio enclosure in an RSS Item
148+///
149+/// # Arguments
150+/// * `item` - The RSS Item to search in
151+///
152+/// # Returns
153+/// * `Some((url, filename, mime_type, file_size))` - The audio enclosure details
154+/// * `None` - If no valid audio enclosure is found
155+fn find_audio_enclosure(item: &Item) -> Option<(String, String, Option<String>, Option<u64>)> {
156+ // List of audio MIME types to look for
157+ let audio_mime_types = [
158+ "audio/mpeg",
159+ "audio/mp3",
160+ "audio/m4a",
161+ "audio/aac",
162+ "audio/wav",
163+ "audio/wave",
164+ "audio/ogg",
165+ "audio/opus",
166+ "audio/flac",
167+ "audio/x-m4a",
168+ "audio/mp4",
169+ ];
170+
171+ // List of audio file extensions to look for
172+ let audio_extensions = [
173+ ".mp3", ".m4a", ".aac", ".wav", ".ogg", ".opus", ".flac", ".mp4",
174+ ];
175+
176+ for enclosure in item.enclosures() {
177+ let url = enclosure.url().to_string();
178+ let mime_type = enclosure.mime_type().map(|s| s.to_string());
179+ let length = enclosure.length();
180+
181+ // Check by MIME type
182+ if let Some(ref mime) = mime_type {
183+ let mime_lower = mime.to_lowercase();
184+ if audio_mime_types.iter().any(|&m| mime_lower == m) {
185+ let filename = extract_filename_from_url(&url);
186+ return Some((url, filename, mime_type, length));
187+ }
188+ }
189+
190+ // Check by URL extension
191+ let url_lower = url.to_lowercase();
192+ if audio_extensions.iter().any(|&ext| url_lower.ends_with(ext)) {
193+ let filename = extract_filename_from_url(&url);
194+ return Some((url, filename, mime_type, length));
195+ }
196+ }
197+
198+ None
199+}
200+
201+/// Extracts filename from a URL
202+fn extract_filename_from_url(url: &str) -> String {
203+ let path = std::path::Path::new(url);
204+ path.file_name()
205+ .and_then(|os_str| os_str.to_str())
206+ .map(|s| s.to_string())
207+ .unwrap_or_else(|| {
208+ // Generate a filename from the URL hash
209+ let hash = md5::compute(url.as_bytes());
210+ format!("{:x}.mp3", hash)
211+ })
212+}
213+
214+/// Parses an RSS date string into a DateTime
215+///
216+/// RSS dates can be in various formats:
217+/// - RFC 2822: "Wed, 21 Oct 2015 07:28:00 GMT"
218+/// - RFC 822: "Wed, 21 Oct 2015 07:28:00 +0000"
219+/// - ISO 8601: "2015-10-21T07:28:00Z"
220+///
221+/// # Arguments
222+/// * `date_str` - The date string to parse
223+///
224+/// # Returns
225+/// * `Ok(DateTime<Utc>)` - The parsed date
226+/// * `Err(String)` - Error message if parsing fails
227+fn parse_rss_date(date_str: &str) -> Result<DateTime<Utc>, String> {
228+ // Try RFC 2822 first (most common in RSS)
229+ if let Ok(date) = chrono::DateTime::parse_from_rfc2822(date_str) {
230+ return Ok(date.with_timezone(&Utc));
231+ }
232+
233+ // Try RFC 822
234+ if let Ok(date) = chrono::DateTime::parse_from_rfc822(date_str) {
235+ return Ok(date.with_timezone(&Utc));
236+ }
237+
238+ // Try ISO 8601
239+ if let Ok(date) = chrono::DateTime::parse_from_rfc3339(date_str) {
240+ return Ok(date.with_timezone(&Utc));
241+ }
242+
243+ // Try various other formats
244+ // Format: "Wed, 21 Oct 2015 07:28:00 GMT"
245+ if let Ok(date) = chrono::NaiveDateTime::parse_from_str(date_str, "%a, %d %b %Y %H:%M:%S %Z") {
246+ return Ok(DateTime::<Utc>::from_utc(date, Utc));
247+ }
248+
249+ // Format: "21 Oct 2015 07:28:00 +0000"
250+ if let Ok(date) = chrono::NaiveDateTime::parse_from_str(date_str, "%d %b %Y %H:%M:%S %z") {
251+ return Ok(DateTime::<Utc>::from_utc(date, Utc));
252+ }
253+
254+ // Try to use chrono's flexible parser
255+ if let Ok(date) = chrono::DateTime::parse_from_str(date_str, "%a, %d %b %Y %H:%M:%S %z") {
256+ return Ok(date.with_timezone(&Utc));
257+ }
258+
259+ // As a last resort, try to parse using diligent-date-parser
260+ if let Ok(parsed) = diligent_date_parser::parse_date(date_str) {
261+ if let Some(datetime) = parsed.datetime {
262+ return Ok(datetime);
263+ }
264+ }
265+
266+ Err(format!("Failed to parse date: {}", date_str))
267+}
268+
269+/// Extracts episodes from an RSS feed and filters by date
270+///
271+/// Only returns episodes published after the given date.
272+///
273+/// # Arguments
274+/// * `channel` - The RSS Channel to extract from
275+/// * `since_date` - Only include episodes published after this date
276+///
277+/// # Returns
278+/// * `Ok(Vec<Episode>)` - Filtered list of episodes
279+/// * `Err(ExtractionError)` - Error if extraction fails
280+pub fn extract_episodes_since(
281+ channel: &Channel,
282+ since_date: DateTime<Utc>,
283+) -> Result<Vec<Episode>, ExtractionError> {
284+ let all_episodes = extract_episodes(channel)?;
285+ let filtered: Vec<Episode> = all_episodes
286+ .into_iter()
287+ .filter(|e| e.pub_date > since_date)
288+ .collect();
289+
290+ if filtered.is_empty() {
291+ info!("No new episodes found since {}", since_date);
292+ }
293+
294+ Ok(filtered)
295+}
296+
297+/// Extracts episodes from an RSS feed and returns only new ones
298+///
299+/// This function compares the episodes with a set of already downloaded episode IDs.
300+///
301+/// # Arguments
302+/// * `channel` - The RSS Channel to extract from
303+/// * `downloaded_ids` - Set of already downloaded episode IDs
304+///
305+/// # Returns
306+/// * `Ok(Vec<Episode>)` - List of new episodes
307+/// * `Err(ExtractionError)` - Error if extraction fails
308+pub fn extract_new_episodes(
309+ channel: &Channel,
310+ downloaded_ids: &HashSet<String>,
311+) -> Result<Vec<Episode>, ExtractionError> {
312+ let all_episodes = extract_episodes(channel)?;
313+ let new_episodes: Vec<Episode> = all_episodes
314+ .into_iter()
315+ .filter(|e| !downloaded_ids.contains(&e.id))
316+ .collect();
317+
318+ if new_episodes.is_empty() {
319+ info!("No new episodes found");
320+ } else {
321+ info!("Found {} new episodes", new_episodes.len());
322+ }
323+
324+ Ok(new_episodes)
325+}
326+
327+#[cfg(test)]
328+mod tests {
329+ use super::*;
330+ use chrono::TimeZone;
331+
332+ #[test]
333+ fn test_parse_rss_date_rfc2822() {
334+ let date_str = "Wed, 21 Oct 2015 07:28:00 GMT";
335+ let result = parse_rss_date(date_str).unwrap();
336+ assert_eq!(result.year(), 2015);
337+ assert_eq!(result.month(), 10);
338+ assert_eq!(result.day(), 21);
339+ }
340+
341+ #[test]
342+ fn test_parse_rss_date_rfc3339() {
343+ let date_str = "2015-10-21T07:28:00Z";
344+ let result = parse_rss_date(date_str).unwrap();
345+ assert_eq!(result.year(), 2015);
346+ assert_eq!(result.month(), 10);
347+ assert_eq!(result.day(), 21);
348+ }
349+
350+ #[test]
351+ fn test_extract_filename_from_url() {
352+ assert_eq!(
353+ extract_filename_from_url("https://example.com/episode.mp3"),
354+ "episode.mp3"
355+ );
356+ assert_eq!(
357+ extract_filename_from_url("https://example.com/path/to/episode.mp3"),
358+ "episode.mp3"
359+ );
360+ assert_eq!(
361+ extract_filename_from_url("https://example.com/episode"),
362+ "episode"
363+ );
364+ }
365+
366+ #[test]
367+ fn test_extract_episodes_empty_feed() {
368+ let channel = Channel::default();
369+ let result = extract_episodes(&channel);
370+ assert!(result.is_err());
371+ }
372+
373+ #[test]
374+ fn test_extraction_error_display() {
375+ let err = ExtractionError::NoItemsFound;
376+ assert!(err.to_string().contains("No items found"));
377+
378+ let err = ExtractionError::NoAudioEpisodes;
379+ assert!(err.to_string().contains("No valid audio episodes"));
380+ }
381+}
modified src/rss/mod.rs +7 -2
@@ -2,7 +2,12 @@
22 //!
33 //! This module handles RSS feed parsing, episode extraction, and downloading.
44
5-pub mod parser;
6-pub mod episode_extractor;
75 pub mod downloader;
6+pub mod episode_extractor;
7+pub mod parser;
88 pub mod sync;
9+
10+// Re-export main types for convenience
11+pub use downloader::{DownloadClient, DownloadError, ProgressCallback, download_episode, download_episodes, download_file, needs_download, remove_downloaded_episode};
12+pub use episode_extractor::{ExtractionError, extract_episodes, extract_episodes_since, extract_new_episodes};
13+pub use parser::{FeedClient, ParserError, fetch_feed, parse_rss_content, parse_feed_from_url, validate_feed_url};
@@ -2,7 +2,12 @@
2 //!2 //!
3 //! This module handles RSS feed parsing, episode extraction, and downloading.3 //! This module handles RSS feed parsing, episode extraction, and downloading.
4 4
5-pub mod parser;
6-pub mod episode_extractor;
7 pub mod downloader;5 pub mod downloader;
6+pub mod episode_extractor;
7+pub mod parser;
8 pub mod sync;8 pub mod sync;
9+
10+// Re-export main types for convenience
11+pub use downloader::{DownloadClient, DownloadError, ProgressCallback, download_episode, download_episodes, download_file, needs_download, remove_downloaded_episode};
12+pub use episode_extractor::{ExtractionError, extract_episodes, extract_episodes_since, extract_new_episodes};
13+pub use parser::{FeedClient, ParserError, fetch_feed, parse_rss_content, parse_feed_from_url, validate_feed_url};
added src/rss/parser.rs +331 -0
new file mode 100644
@@ -0,0 +1,331 @@
1+//! RSS Parser module
2+//!
3+//! This module handles fetching and parsing RSS/Atom feeds.
4+
5+use log::{debug, error, info, warn};
6+use reqwest::Client;
7+use rss::Channel;
8+use std::time::Duration;
9+use thiserror::Error;
10+
11+/// Maximum number of retries for fetching a feed
12+const MAX_RETRIES: u32 = 3;
13+
14+/// Timeout for HTTP requests (in seconds)
15+const REQUEST_TIMEOUT_SECS: u64 = 30;
16+
17+/// Error type for RSS parsing operations
18+#[derive(Debug, Error)]
19+pub enum ParserError {
20+ /// HTTP request failed
21+ #[error("HTTP request failed: {0}")]
22+ HttpError(String),
23+
24+ /// Request timeout
25+ #[error("Request timeout after {0} seconds")]
26+ Timeout(u64),
27+
28+ /// Invalid URL
29+ #[error("Invalid URL: {0}")]
30+ InvalidUrl(String),
31+
32+ /// Failed to parse RSS content
33+ #[error("Failed to parse RSS content: {0}")]
34+ ParseError(String),
35+
36+ /// No valid feed data found
37+ #[error("No valid feed data found")]
38+ NoFeedData,
39+
40+ /// Too many redirects
41+ #[error("Too many redirects")]
42+ TooManyRedirects,
43+
44+ /// SSL/TLS error
45+ #[error("SSL/TLS error: {0}")]
46+ SslError(String),
47+}
48+
49+/// HTTP client with custom configuration for feed fetching
50+pub struct FeedClient {
51+ client: Client,
52+}
53+
54+impl Default for FeedClient {
55+ fn default() -> Self {
56+ Self::new()
57+ }
58+}
59+
60+impl FeedClient {
61+ /// Creates a new FeedClient with custom configuration
62+ pub fn new() -> Self {
63+ let client = Client::builder()
64+ .timeout(Duration::from_secs(REQUEST_TIMEOUT_SECS))
65+ .redirect(reqwest::redirect::Policy::limited(5))
66+ .user_agent("RSS-Podcast-Downloader/1.0")
67+ .build()
68+ .expect("Failed to create HTTP client");
69+
70+ Self { client }
71+ }
72+
73+ /// Creates a client with custom timeout
74+ pub fn with_timeout(timeout_secs: u64) -> Self {
75+ let client = Client::builder()
76+ .timeout(Duration::from_secs(timeout_secs))
77+ .redirect(reqwest::redirect::Policy::limited(5))
78+ .user_agent("RSS-Podcast-Downloader/1.0")
79+ .build()
80+ .expect("Failed to create HTTP client");
81+
82+ Self { client }
83+ }
84+}
85+
86+/// Fetches the content of an RSS feed from a URL
87+///
88+/// This function attempts to fetch the feed content with retries on failure.
89+///
90+/// # Arguments
91+/// * `url` - The URL of the RSS feed
92+/// * `retries` - Number of retries on failure (default: MAX_RETRIES)
93+///
94+/// # Returns
95+/// * `Ok(String)` - The feed content as a string
96+/// * `Err(ParserError)` - Error if fetching fails
97+pub async fn fetch_feed(url: &str) -> Result<String, ParserError> {
98+ fetch_feed_with_client(url, &FeedClient::default(), MAX_RETRIES).await
99+}
100+
101+/// Fetches the content of an RSS feed using a custom client
102+///
103+/// # Arguments
104+/// * `url` - The URL of the RSS feed
105+/// * `client` - Custom HTTP client
106+/// * `retries` - Number of retries on failure
107+///
108+/// # Returns
109+/// * `Ok(String)` - The feed content as a string
110+/// * `Err(ParserError)` - Error if fetching fails
111+pub async fn fetch_feed_with_client(
112+ url: &str,
113+ client: &FeedClient,
114+ retries: u32,
115+) -> Result<String, ParserError> {
116+ // Validate URL
117+ if url.is_empty() {
118+ return Err(ParserError::InvalidUrl("URL cannot be empty".to_string()));
119+ }
120+
121+ // Check URL format
122+ if !url.starts_with("http://") && !url.starts_with("https://") {
123+ return Err(ParserError::InvalidUrl(
124+ "URL must start with http:// or https://".to_string(),
125+ ));
126+ }
127+
128+ let mut last_error: Option<ParserError> = None;
129+
130+ for attempt in 0..=retries {
131+ if attempt > 0 {
132+ debug!(
133+ "Retry {} for {} (attempt {}/{})",
134+ url, attempt, retries
135+ );
136+ // Add delay between retries
137+ tokio::time::sleep(Duration::from_secs(1 << attempt.min(5))).await;
138+ }
139+
140+ match fetch_feed_once(url, client).await {
141+ Ok(content) => {
142+ info!("Successfully fetched feed from {}", url);
143+ return Ok(content);
144+ }
145+ Err(e) => {
146+ last_error = Some(e);
147+ warn!(
148+ "Failed to fetch feed from {} (attempt {}/{}): {}",
149+ url, attempt, retries, last_error.as_ref().unwrap()
150+ );
151+ }
152+ }
153+ }
154+
155+ Err(last_error.unwrap_or(ParserError::HttpError("Unknown error".to_string())))
156+}
157+
158+/// Single attempt to fetch feed content
159+async fn fetch_feed_once(url: &str, client: &FeedClient) -> Result<String, ParserError> {
160+ let response = match client.client.get(url).send().await {
161+ Ok(resp) => resp,
162+ Err(e) => {
163+ if e.is_timeout() {
164+ return Err(ParserError::Timeout(REQUEST_TIMEOUT_SECS));
165+ }
166+
167+ // Check if it's an SSL error
168+ if e.to_string().contains("ssl") || e.to_string().contains("tls") {
169+ return Err(ParserError::SslError(e.to_string()));
170+ }
171+
172+ return Err(ParserError::HttpError(e.to_string()));
173+ }
174+ };
175+
176+ // Check status code
177+ if !response.status().is_success() {
178+ let status = response.status();
179+ if status.is_client_error() || status.is_server_error() {
180+ return Err(ParserError::HttpError(format!(
181+ "HTTP {}: {}",
182+ status.as_u16(),
183+ status.canonical_reason().unwrap_or("Unknown error")
184+ )));
185+ }
186+ }
187+
188+ // Get the content type to determine encoding
189+ let content_type = response
190+ .headers()
191+ .get("content-type")
192+ .and_then(|h| h.to_str().ok())
193+ .map(|s| s.to_lowercase());
194+
195+ // Read the response body
196+ let content = response.text().await.map_err(|e| ParserError::HttpError(e.to_string()))?;
197+
198+ // Check if content is empty
199+ if content.trim().is_empty() {
200+ return Err(ParserError::NoFeedData);
201+ }
202+
203+ Ok(content)
204+}
205+
206+/// Parses RSS/Atom feed content into a Channel structure
207+///
208+/// This function parses the feed content and returns a normalized Channel structure.
209+/// It handles both RSS 2.0 and Atom formats.
210+///
211+/// # Arguments
212+/// * `content` - The feed content as a string
213+///
214+/// # Returns
215+/// * `Ok(Channel)` - The parsed feed as a Channel
216+/// * `Err(ParserError)` - Error if parsing fails
217+pub fn parse_rss_content(content: &str) -> Result<Channel, ParserError> {
218+ // Try to parse as RSS 2.0 first
219+ match Channel::read_from(content) {
220+ Ok(channel) => {
221+ debug!("Successfully parsed as RSS 2.0");
222+ return Ok(channel);
223+ }
224+ Err(e) => {
225+ debug!("Failed to parse as RSS 2.0: {}", e);
226+ }
227+ }
228+
229+ // Try to parse as Atom
230+ // The rss crate can handle Atom feeds through the atom_syndication feature
231+ // If that doesn't work, we'll try manual parsing
232+
233+ // For now, return an error if RSS parsing fails
234+ // In a production environment, we would implement Atom parsing here
235+ Err(ParserError::ParseError(
236+ "Failed to parse feed content as RSS or Atom".to_string(),
237+ ))
238+}
239+
240+/// Parses and validates an RSS feed from a URL
241+///
242+/// This is a convenience function that combines fetch_feed and parse_rss_content.
243+///
244+/// # Arguments
245+/// * `url` - The URL of the RSS feed
246+///
247+/// # Returns
248+/// * `Ok(Channel)` - The parsed feed
249+/// * `Err(ParserError)` - Error if fetching or parsing fails
250+pub async fn parse_feed_from_url(url: &str) -> Result<Channel, ParserError> {
251+ let content = fetch_feed(url).await?;
252+ parse_rss_content(&content)
253+}
254+
255+/// Validates that a feed URL points to a valid RSS/Atom feed
256+///
257+/// This function checks the Content-Type header and tries to parse a small portion
258+/// of the content to verify it's a valid feed.
259+///
260+/// # Arguments
261+/// * `url` - The URL to validate
262+///
263+/// # Returns
264+/// * `Ok(())` - If the URL appears to be a valid feed
265+/// * `Err(ParserError)` - If validation fails
266+pub async fn validate_feed_url(url: &str) -> Result<(), ParserError> {
267+ // First, check URL format
268+ if url.is_empty() {
269+ return Err(ParserError::InvalidUrl("URL cannot be empty".to_string()));
270+ }
271+
272+ if !url.starts_with("http://") && !url.starts_with("https://") {
273+ return Err(ParserError::InvalidUrl(
274+ "URL must start with http:// or https://".to_string(),
275+ ));
276+ }
277+
278+ // Try to fetch and parse the feed
279+ let _ = parse_feed_from_url(url).await?;
280+
281+ Ok(())
282+}
283+
284+#[cfg(test)]
285+mod tests {
286+ use super::*;
287+ use mockito::{mock, Server};
288+ use std::sync::Once;
289+
290+ // Initialize mockito server once
291+ static INIT: Once = Once::new();
292+
293+ fn init_mock_server() {
294+ INIT.call_once(|| {
295+ // This will start the mock server
296+ let _server = Server::new();
297+ });
298+ }
299+
300+ #[tokio::test]
301+ async fn test_validate_url_valid() {
302+ assert!(FeedClient::new().client.get("https://example.com").is_err().not());
303+ }
304+
305+ #[test]
306+ fn test_parser_error_display() {
307+ let err = ParserError::HttpError("Connection refused".to_string());
308+ assert!(err.to_string().contains("Connection refused"));
309+
310+ let err = ParserError::ParseError("Invalid XML".to_string());
311+ assert!(err.to_string().contains("Invalid XML"));
312+
313+ let err = ParserError::NoFeedData;
314+ assert!(err.to_string().contains("No valid feed data"));
315+ }
316+
317+ #[test]
318+ fn test_feed_client_new() {
319+ let client = FeedClient::new();
320+ assert!(!client.client.to_string().is_empty());
321+ }
322+
323+ #[tokio::test]
324+ async fn test_fetch_feed_invalid_url() {
325+ let result = fetch_feed("").await;
326+ assert!(result.is_err());
327+
328+ let result = fetch_feed("not-a-url").await;
329+ assert!(result.is_err());
330+ }
331+}
new file mode 100644
@@ -0,0 +1,331 @@
1+//! RSS Parser module
2+//!
3+//! This module handles fetching and parsing RSS/Atom feeds.
4+
5+use log::{debug, error, info, warn};
6+use reqwest::Client;
7+use rss::Channel;
8+use std::time::Duration;
9+use thiserror::Error;
10+
11+/// Maximum number of retries for fetching a feed
12+const MAX_RETRIES: u32 = 3;
13+
14+/// Timeout for HTTP requests (in seconds)
15+const REQUEST_TIMEOUT_SECS: u64 = 30;
16+
17+/// Error type for RSS parsing operations
18+#[derive(Debug, Error)]
19+pub enum ParserError {
20+ /// HTTP request failed
21+ #[error("HTTP request failed: {0}")]
22+ HttpError(String),
23+
24+ /// Request timeout
25+ #[error("Request timeout after {0} seconds")]
26+ Timeout(u64),
27+
28+ /// Invalid URL
29+ #[error("Invalid URL: {0}")]
30+ InvalidUrl(String),
31+
32+ /// Failed to parse RSS content
33+ #[error("Failed to parse RSS content: {0}")]
34+ ParseError(String),
35+
36+ /// No valid feed data found
37+ #[error("No valid feed data found")]
38+ NoFeedData,
39+
40+ /// Too many redirects
41+ #[error("Too many redirects")]
42+ TooManyRedirects,
43+
44+ /// SSL/TLS error
45+ #[error("SSL/TLS error: {0}")]
46+ SslError(String),
47+}
48+
49+/// HTTP client with custom configuration for feed fetching
50+pub struct FeedClient {
51+ client: Client,
52+}
53+
54+impl Default for FeedClient {
55+ fn default() -> Self {
56+ Self::new()
57+ }
58+}
59+
60+impl FeedClient {
61+ /// Creates a new FeedClient with custom configuration
62+ pub fn new() -> Self {
63+ let client = Client::builder()
64+ .timeout(Duration::from_secs(REQUEST_TIMEOUT_SECS))
65+ .redirect(reqwest::redirect::Policy::limited(5))
66+ .user_agent("RSS-Podcast-Downloader/1.0")
67+ .build()
68+ .expect("Failed to create HTTP client");
69+
70+ Self { client }
71+ }
72+
73+ /// Creates a client with custom timeout
74+ pub fn with_timeout(timeout_secs: u64) -> Self {
75+ let client = Client::builder()
76+ .timeout(Duration::from_secs(timeout_secs))
77+ .redirect(reqwest::redirect::Policy::limited(5))
78+ .user_agent("RSS-Podcast-Downloader/1.0")
79+ .build()
80+ .expect("Failed to create HTTP client");
81+
82+ Self { client }
83+ }
84+}
85+
86+/// Fetches the content of an RSS feed from a URL
87+///
88+/// This function attempts to fetch the feed content with retries on failure.
89+///
90+/// # Arguments
91+/// * `url` - The URL of the RSS feed
92+/// * `retries` - Number of retries on failure (default: MAX_RETRIES)
93+///
94+/// # Returns
95+/// * `Ok(String)` - The feed content as a string
96+/// * `Err(ParserError)` - Error if fetching fails
97+pub async fn fetch_feed(url: &str) -> Result<String, ParserError> {
98+ fetch_feed_with_client(url, &FeedClient::default(), MAX_RETRIES).await
99+}
100+
101+/// Fetches the content of an RSS feed using a custom client
102+///
103+/// # Arguments
104+/// * `url` - The URL of the RSS feed
105+/// * `client` - Custom HTTP client
106+/// * `retries` - Number of retries on failure
107+///
108+/// # Returns
109+/// * `Ok(String)` - The feed content as a string
110+/// * `Err(ParserError)` - Error if fetching fails
111+pub async fn fetch_feed_with_client(
112+ url: &str,
113+ client: &FeedClient,
114+ retries: u32,
115+) -> Result<String, ParserError> {
116+ // Validate URL
117+ if url.is_empty() {
118+ return Err(ParserError::InvalidUrl("URL cannot be empty".to_string()));
119+ }
120+
121+ // Check URL format
122+ if !url.starts_with("http://") && !url.starts_with("https://") {
123+ return Err(ParserError::InvalidUrl(
124+ "URL must start with http:// or https://".to_string(),
125+ ));
126+ }
127+
128+ let mut last_error: Option<ParserError> = None;
129+
130+ for attempt in 0..=retries {
131+ if attempt > 0 {
132+ debug!(
133+ "Retry {} for {} (attempt {}/{})",
134+ url, attempt, retries
135+ );
136+ // Add delay between retries
137+ tokio::time::sleep(Duration::from_secs(1 << attempt.min(5))).await;
138+ }
139+
140+ match fetch_feed_once(url, client).await {
141+ Ok(content) => {
142+ info!("Successfully fetched feed from {}", url);
143+ return Ok(content);
144+ }
145+ Err(e) => {
146+ last_error = Some(e);
147+ warn!(
148+ "Failed to fetch feed from {} (attempt {}/{}): {}",
149+ url, attempt, retries, last_error.as_ref().unwrap()
150+ );
151+ }
152+ }
153+ }
154+
155+ Err(last_error.unwrap_or(ParserError::HttpError("Unknown error".to_string())))
156+}
157+
158+/// Single attempt to fetch feed content
159+async fn fetch_feed_once(url: &str, client: &FeedClient) -> Result<String, ParserError> {
160+ let response = match client.client.get(url).send().await {
161+ Ok(resp) => resp,
162+ Err(e) => {
163+ if e.is_timeout() {
164+ return Err(ParserError::Timeout(REQUEST_TIMEOUT_SECS));
165+ }
166+
167+ // Check if it's an SSL error
168+ if e.to_string().contains("ssl") || e.to_string().contains("tls") {
169+ return Err(ParserError::SslError(e.to_string()));
170+ }
171+
172+ return Err(ParserError::HttpError(e.to_string()));
173+ }
174+ };
175+
176+ // Check status code
177+ if !response.status().is_success() {
178+ let status = response.status();
179+ if status.is_client_error() || status.is_server_error() {
180+ return Err(ParserError::HttpError(format!(
181+ "HTTP {}: {}",
182+ status.as_u16(),
183+ status.canonical_reason().unwrap_or("Unknown error")
184+ )));
185+ }
186+ }
187+
188+ // Get the content type to determine encoding
189+ let content_type = response
190+ .headers()
191+ .get("content-type")
192+ .and_then(|h| h.to_str().ok())
193+ .map(|s| s.to_lowercase());
194+
195+ // Read the response body
196+ let content = response.text().await.map_err(|e| ParserError::HttpError(e.to_string()))?;
197+
198+ // Check if content is empty
199+ if content.trim().is_empty() {
200+ return Err(ParserError::NoFeedData);
201+ }
202+
203+ Ok(content)
204+}
205+
206+/// Parses RSS/Atom feed content into a Channel structure
207+///
208+/// This function parses the feed content and returns a normalized Channel structure.
209+/// It handles both RSS 2.0 and Atom formats.
210+///
211+/// # Arguments
212+/// * `content` - The feed content as a string
213+///
214+/// # Returns
215+/// * `Ok(Channel)` - The parsed feed as a Channel
216+/// * `Err(ParserError)` - Error if parsing fails
217+pub fn parse_rss_content(content: &str) -> Result<Channel, ParserError> {
218+ // Try to parse as RSS 2.0 first
219+ match Channel::read_from(content) {
220+ Ok(channel) => {
221+ debug!("Successfully parsed as RSS 2.0");
222+ return Ok(channel);
223+ }
224+ Err(e) => {
225+ debug!("Failed to parse as RSS 2.0: {}", e);
226+ }
227+ }
228+
229+ // Try to parse as Atom
230+ // The rss crate can handle Atom feeds through the atom_syndication feature
231+ // If that doesn't work, we'll try manual parsing
232+
233+ // For now, return an error if RSS parsing fails
234+ // In a production environment, we would implement Atom parsing here
235+ Err(ParserError::ParseError(
236+ "Failed to parse feed content as RSS or Atom".to_string(),
237+ ))
238+}
239+
240+/// Parses and validates an RSS feed from a URL
241+///
242+/// This is a convenience function that combines fetch_feed and parse_rss_content.
243+///
244+/// # Arguments
245+/// * `url` - The URL of the RSS feed
246+///
247+/// # Returns
248+/// * `Ok(Channel)` - The parsed feed
249+/// * `Err(ParserError)` - Error if fetching or parsing fails
250+pub async fn parse_feed_from_url(url: &str) -> Result<Channel, ParserError> {
251+ let content = fetch_feed(url).await?;
252+ parse_rss_content(&content)
253+}
254+
255+/// Validates that a feed URL points to a valid RSS/Atom feed
256+///
257+/// This function checks the Content-Type header and tries to parse a small portion
258+/// of the content to verify it's a valid feed.
259+///
260+/// # Arguments
261+/// * `url` - The URL to validate
262+///
263+/// # Returns
264+/// * `Ok(())` - If the URL appears to be a valid feed
265+/// * `Err(ParserError)` - If validation fails
266+pub async fn validate_feed_url(url: &str) -> Result<(), ParserError> {
267+ // First, check URL format
268+ if url.is_empty() {
269+ return Err(ParserError::InvalidUrl("URL cannot be empty".to_string()));
270+ }
271+
272+ if !url.starts_with("http://") && !url.starts_with("https://") {
273+ return Err(ParserError::InvalidUrl(
274+ "URL must start with http:// or https://".to_string(),
275+ ));
276+ }
277+
278+ // Try to fetch and parse the feed
279+ let _ = parse_feed_from_url(url).await?;
280+
281+ Ok(())
282+}
283+
284+#[cfg(test)]
285+mod tests {
286+ use super::*;
287+ use mockito::{mock, Server};
288+ use std::sync::Once;
289+
290+ // Initialize mockito server once
291+ static INIT: Once = Once::new();
292+
293+ fn init_mock_server() {
294+ INIT.call_once(|| {
295+ // This will start the mock server
296+ let _server = Server::new();
297+ });
298+ }
299+
300+ #[tokio::test]
301+ async fn test_validate_url_valid() {
302+ assert!(FeedClient::new().client.get("https://example.com").is_err().not());
303+ }
304+
305+ #[test]
306+ fn test_parser_error_display() {
307+ let err = ParserError::HttpError("Connection refused".to_string());
308+ assert!(err.to_string().contains("Connection refused"));
309+
310+ let err = ParserError::ParseError("Invalid XML".to_string());
311+ assert!(err.to_string().contains("Invalid XML"));
312+
313+ let err = ParserError::NoFeedData;
314+ assert!(err.to_string().contains("No valid feed data"));
315+ }
316+
317+ #[test]
318+ fn test_feed_client_new() {
319+ let client = FeedClient::new();
320+ assert!(!client.client.to_string().is_empty());
321+ }
322+
323+ #[tokio::test]
324+ async fn test_fetch_feed_invalid_url() {
325+ let result = fetch_feed("").await;
326+ assert!(result.is_err());
327+
328+ let result = fetch_feed("not-a-url").await;
329+ assert!(result.is_err());
330+ }
331+}
added src/rss/sync.rs +5 -0
new file mode 100644
@@ -0,0 +1,5 @@
1+//! RSS Synchronization module (to be implemented in Phase 5)
2+//!
3+//! This module will handle synchronization of RSS feeds and downloading new episodes.
4+//!
5+//! Placeholder for Phase 5 implementation
new file mode 100644
@@ -0,0 +1,5 @@
1+//! RSS Synchronization module (to be implemented in Phase 5)
2+//!
3+//! This module will handle synchronization of RSS feeds and downloading new episodes.
4+//!
5+//! Placeholder for Phase 5 implementation