feedback

Author: van-sprundel

src/config.rs

@@ -324,21 +324,13 @@ impl Config {
             "embedded" => {
                 // No validation needed - embedded indexers are built-in
             }
-            "prowlarr" => {
-                // Prowlarr mode requires prowlarr config
+            "prowlarr" | "both" => {
+                // Prowlarr or both mode requires prowlarr config
                 if self.prowlarr.is_none() {
-                    return Err(ConfigError::ValidationError(
-                        "indexers.mode is 'prowlarr' but prowlarr config is missing".to_string(),
-                    ));
-                }
-                self.validate_prowlarr_config()?;
-            }
-            "both" => {
-                // Both mode requires prowlarr config
-                if self.prowlarr.is_none() {
-                    return Err(ConfigError::ValidationError(
-                        "indexers.mode is 'both' but prowlarr config is missing".to_string(),
-                    ));
+                    return Err(ConfigError::ValidationError(format!(
+                        "indexers.mode is '{}' but prowlarr config is missing",
+                        self.indexers.mode
+                    )));
                 }
                 self.validate_prowlarr_config()?;
             }

src/indexers/mod.rs

@@ -105,13 +105,16 @@ impl IndexerManager {
 
         let mut all_results = Vec::new();
 
+        // Convert query to String once, then clone for each indexer
+        let query = query.to_string();
+
         // Create search tasks for all enabled indexers
         let search_futures: Vec<_> = self
             .indexers
             .iter()
             .filter(|indexer| indexer.is_enabled())
             .map(|indexer| {
-                let query = query.to_string();
+                let query = query.clone();
                 async move {
                     let name = indexer.name();
                     match indexer.search(&query, categories).await {

src/indexers/x1337.rs

@@ -3,6 +3,7 @@
 use super::{IndexerError, TorrentIndexer, common};
 use crate::torznab::TorrentResult;
 use async_trait::async_trait;
+use futures::future::join_all;
 use reqwest::Client;
 use scraper::{Html, Selector};
 
@@ -42,6 +43,25 @@ impl X1337Indexer {
         Ok(response.text().await?)
     }
 
+    /// Fetch the magnet URL from a 1337x detail page
+    async fn fetch_magnet_url(&self, detail_url: &str) -> Result<String, IndexerError> {
+        let html = self.fetch_html(detail_url).await?;
+        let document = Html::parse_document(&html);
+
+        // The magnet link is in an anchor with href starting with "magnet:"
+        let magnet_selector = Selector::parse("a[href^='magnet:']")
+            .map_err(|e| IndexerError::ParseError(format!("Invalid selector: {}", e)))?;
+
+        document
+            .select(&magnet_selector)
+            .next()
+            .and_then(|elem| elem.value().attr("href"))
+            .map(String::from)
+            .ok_or_else(|| {
+                IndexerError::ParseError("Magnet link not found on detail page".to_string())
+            })
+    }
+
     fn parse_results(&self, html: &str) -> Result<Vec<TorrentResult>, IndexerError> {
         let document = Html::parse_document(html);
 
@@ -132,9 +152,33 @@ impl TorrentIndexer for X1337Indexer {
         tracing::debug!(url, "1337x: searching");
 
         let html = self.fetch_html(&url).await?;
-        let results = self.parse_results(&html)?;
+        let mut results = self.parse_results(&html)?;
+
+        tracing::debug!(
+            count = results.len(),
+            "1337x: found results, fetching magnet URLs"
+        );
+
+        // Fetch magnet URLs from detail pages in parallel
+        let detail_urls: Vec<_> = results.iter().filter_map(|r| r.link.clone()).collect();
+        let magnet_futures: Vec<_> = detail_urls
+            .iter()
+            .map(|detail_url| self.fetch_magnet_url(detail_url))
+            .collect();
+
+        let magnets = join_all(magnet_futures).await;
+
+        // Update results with fetched magnet URLs
+        for (result, magnet_result) in results.iter_mut().zip(magnets.into_iter()) {
+            if let Ok(magnet) = magnet_result {
+                result.magnet_url = Some(magnet);
+            }
+        }
+
+        // Filter out results without magnet URLs
+        results.retain(|r| r.magnet_url.is_some());
 
-        tracing::debug!(count = results.len(), "1337x: found results");
+        tracing::debug!(count = results.len(), "1337x: results with magnet URLs");
 
         if results.is_empty() {
             Err(IndexerError::NotFound)

src/tui/mod.rs

@@ -2574,19 +2574,16 @@ fn apply_settings_edit(app: &App, config: &mut Config) {
 
     match app.settings_section {
         SettingsSection::Prowlarr => {
-            // Ensure prowlarr config exists
-            if config.prowlarr.is_none() {
-                config.prowlarr = Some(crate::config::ProwlarrConfig {
+            let prowlarr = config
+                .prowlarr
+                .get_or_insert_with(|| crate::config::ProwlarrConfig {
                     url: String::new(),
                     apikey: String::new(),
                 });
-            }
-            if let Some(ref mut prowlarr) = config.prowlarr {
-                match app.settings_field_index {
-                    0 => prowlarr.url = value,
-                    1 => prowlarr.apikey = value,
-                    _ => {}
-                }
+            match app.settings_field_index {
+                0 => prowlarr.url = value,
+                1 => prowlarr.apikey = value,
+                _ => {}
             }
         }
         SettingsSection::Tmdb => {
@@ -2746,19 +2743,16 @@ fn apply_wizard_edit(app: &App, config: &mut Config) {
 
     match app.wizard_step {
         WizardStep::Prowlarr => {
-            // Ensure prowlarr config exists
-            if config.prowlarr.is_none() {
-                config.prowlarr = Some(crate::config::ProwlarrConfig {
+            let prowlarr = config
+                .prowlarr
+                .get_or_insert_with(|| crate::config::ProwlarrConfig {
                     url: String::new(),
                     apikey: String::new(),
                 });
-            }
-            if let Some(ref mut prowlarr) = config.prowlarr {
-                match app.wizard_field_index {
-                    0 => prowlarr.url = value,
-                    1 => prowlarr.apikey = value,
-                    _ => {}
-                }
+            match app.wizard_field_index {
+                0 => prowlarr.url = value,
+                1 => prowlarr.apikey = value,
+                _ => {}
             }
         }
         WizardStep::Tmdb => {