more fixes

src/providers/noodlemagazine.rs

@@ -7,43 +7,45 @@ use crate::util::requester::Requester;
 use crate::util::parse_abbreviated_number;
 use crate::util::time::parse_time_to_seconds;
 use crate::videos::{ServerOptions, VideoFormat, VideoItem};
+
 use async_trait::async_trait;
 use error_chain::error_chain;
 use futures::future::join_all;
-use htmlentity::entity::{ICodedDataTrait, decode};
+use htmlentity::entity::{decode, ICodedDataTrait};
 use wreq::Version;
-use std::{vec};
 use titlecase::Titlecase;
+use std::vec;
 
 error_chain! {
     foreign_links {
         Io(std::io::Error);
         HttpRequest(wreq::Error);
     }
+    errors {
+        Parse(msg: String)
+    }
 }
 
 #[derive(Debug, Clone)]
 pub struct NoodlemagazineProvider {
     url: String,
 }
+
 impl NoodlemagazineProvider {
     pub fn new() -> Self {
-        let provider = NoodlemagazineProvider {
+        Self {
             url: "https://noodlemagazine.com".to_string(),
-        };
+        }
-        provider
     }
 
-    fn build_channel(&self, clientversion: ClientVersion) -> Channel {
+    fn build_channel(&self, _clientversion: ClientVersion) -> Channel {
-        let _ = clientversion;
         Channel {
-            id: "noodlemagazine".to_string(),
+            id: "noodlemagazine".into(),
-            name: "Noodlemagazine".to_string(),
+            name: "Noodlemagazine".into(),
-            description: "The Best Search Engine of HD Videos".to_string(),
+            description: "The Best Search Engine of HD Videos".into(),
             premium: false,
-            favicon: "https://www.google.com/s2/favicons?sz=64&domain=noodlemagazine.com"
+            favicon: "https://www.google.com/s2/favicons?sz=64&domain=noodlemagazine.com".into(),
-                .to_string(),
+            status: "active".into(),
-            status: "active".to_string(),
             categories: vec![],
             options: vec![],
             nsfw: true,
@@ -55,40 +57,40 @@ impl NoodlemagazineProvider {
         &self,
         cache: VideoCache,
         page: u8,
-        sort: &str,
+        _sort: &str,
         options: ServerOptions,
     ) -> Result<Vec<VideoItem>> {
-        let _ = sort;
         let video_url = format!(
             "{}/popular/recent?sort_by=views&sort_order=desc&p={}",
             self.url,
-            page - 1
+            page.saturating_sub(1)
         );
+
         let old_items = match cache.get(&video_url) {
-            Some((time, items)) => {
+            Some((t, i)) if t.elapsed().unwrap_or_default().as_secs() < 300 => return Ok(i.clone()),
-                if time.elapsed().unwrap_or_default().as_secs() < 60 * 5 {
+            Some((_, i)) => i.clone(),
-                    return Ok(items.clone());
+            None => vec![],
-                } else {
-                    items.clone()
-                }
-            }
-            None => {
-                vec![]
-            }
         };
 
-        let mut requester = options.requester.clone().unwrap();
+        let mut requester = match options.requester.clone() {
-        let text = requester.get(&video_url, Some(Version::HTTP_2)).await.unwrap();
+            Some(r) => r,
-        let video_items: Vec<VideoItem> = self
+            None => return Ok(old_items),
-            .get_video_items_from_html(text.clone(), requester.clone())
+        };
-            .await;
+
-        if !video_items.is_empty() {
+        let text = requester
-            cache.remove(&video_url);
+            .get(&video_url, Some(Version::HTTP_2))
-            cache.insert(video_url.clone(), video_items.clone());
+            .await
+            .unwrap_or_default();
+
+        let items = self.get_video_items_from_html(text, requester).await;
+
+        if items.is_empty() {
+            Ok(old_items)
         } else {
-            return Ok(old_items);
+            cache.remove(&video_url);
+            cache.insert(video_url, items.clone());
+            Ok(items)
         }
-        Ok(video_items)
     }
 
     async fn query(
@@ -98,37 +100,34 @@ impl NoodlemagazineProvider {
         query: &str,
         options: ServerOptions,
     ) -> Result<Vec<VideoItem>> {
-        let search_string = query.trim().replace(" ", "%20").to_string();
+        let q = query.trim().replace(' ', "%20");
+        let video_url = format!("{}/video/{}?p={}", self.url, q, page.saturating_sub(1));
 
-        let video_url = format!("{}/video/{}?p={}", self.url, search_string, page - 1);
-        // Check our Video Cache. If the result is younger than 1 hour, we return it.
         let old_items = match cache.get(&video_url) {
-            Some((time, items)) => {
+            Some((t, i)) if t.elapsed().unwrap_or_default().as_secs() < 300 => return Ok(i.clone()),
-                if time.elapsed().unwrap_or_default().as_secs() < 60 * 5 {
+            Some((_, i)) => i.clone(),
-                    return Ok(items.clone());
+            None => vec![],
-                } else {
-                    let _ = cache.check().await;
-                    return Ok(items.clone());
-                }
-            }
-            None => {
-                vec![]
-            }
         };
 
-        let mut requester = options.requester.clone().unwrap();
+        let mut requester = match options.requester.clone() {
+            Some(r) => r,
+            None => return Ok(old_items),
+        };
 
-        let text = requester.get(&video_url, Some(Version::HTTP_2)).await.unwrap();
+        let text = requester
-        let video_items: Vec<VideoItem> = self
+            .get(&video_url, Some(Version::HTTP_2))
-            .get_video_items_from_html(text.clone(), requester.clone())
+            .await
-            .await;
+            .unwrap_or_default();
-        if !video_items.is_empty() {
+
-            cache.remove(&video_url);
+        let items = self.get_video_items_from_html(text, requester).await;
-            cache.insert(video_url.clone(), video_items.clone());
+
+        if items.is_empty() {
+            Ok(old_items)
         } else {
-            return Ok(old_items);
+            cache.remove(&video_url);
+            cache.insert(video_url, items.clone());
+            Ok(items)
         }
-        Ok(video_items)
     }
 
     async fn get_video_items_from_html(
@@ -139,19 +138,29 @@ impl NoodlemagazineProvider {
         if html.is_empty() || html.contains("404 Not Found") {
             return vec![];
         }
-        let raw_videos = html.split(">Show more</div>").collect::<Vec<&str>>()[0]
-            .split("<div class=\"list_videos\" id=\"list_videos\">")
-            .collect::<Vec<&str>>()[1]
-            .split("<div class=\"item\">")
-            .collect::<Vec<&str>>()[1..]
-            .to_vec();
 
-        let futures = raw_videos
+        let section = match html.split(">Show more</div>").next() {
-            .into_iter()
+            Some(s) => s,
-            .map(|el| self.get_video_item(el.to_string(), requester.clone()));
+            None => return vec![],
-        let results: Vec<Result<VideoItem>> = join_all(futures).await;
+        };
-        let video_items: Vec<VideoItem> = results.into_iter().filter_map(Result::ok).collect();
+
-        return video_items;
+        let list = match section
+            .split("<div class=\"list_videos\" id=\"list_videos\">")
+            .nth(1)
+        {
+            Some(l) => l,
+            None => return vec![],
+        };
+
+        let raw_videos = list
+            .split("<div class=\"item\">")
+            .skip(1)
+            .map(|s| s.to_string());
+
+        let futures = raw_videos.map(|v| self.get_video_item(v, requester.clone()));
+        let results = join_all(futures).await;
+
+        results.into_iter().filter_map(Result::ok).collect()
     }
 
     async fn get_video_item(
@@ -159,97 +168,109 @@ impl NoodlemagazineProvider {
         video_segment: String,
         requester: Requester,
     ) -> Result<VideoItem> {
-        let video_url: String = format!(
+        let href = video_segment
-            "{}{}",
+            .split("<a href=\"")
-            self.url,
+            .nth(1)
-            video_segment.split("<a href=\"").collect::<Vec<&str>>()[1]
+            .and_then(|s| s.split('"').next())
-                .split("\"")
+            .ok_or_else(|| Error::from("missing href"))?;
-                .collect::<Vec<&str>>()[0]
+
-                .to_string()
+        let video_url = format!("{}{}", self.url, href);
-        );
+
         let mut title = video_segment
             .split("<div class=\"title\">")
-            .collect::<Vec<&str>>()[1]
+            .nth(1)
-            .split("<")
+            .and_then(|s| s.split('<').next())
-            .collect::<Vec<&str>>()[0]
+            .unwrap_or("")
             .trim()
             .to_string();
-        // html decode
+
         title = decode(title.as_bytes())
             .to_string()
             .unwrap_or(title)
             .titlecase();
-        let id = video_url.split("/").collect::<Vec<&str>>()[4]
+
-            .split(".")
+        let id = video_url
-            .collect::<Vec<&str>>()[0]
+            .split('/')
+            .nth(4)
+            .and_then(|s| s.split('.').next())
+            .ok_or_else(|| Error::from("missing id"))?
             .to_string();
 
-        let thumb = video_segment.split("<img ").collect::<Vec<&str>>()[1]
+        let thumb = video_segment
             .split("data-src=\"")
-            .collect::<Vec<&str>>()[1]
+            .nth(1)
-            .split("\"")
+            .and_then(|s| s.split('"').next())
-            .collect::<Vec<&str>>()[0]
+            .unwrap_or("")
             .to_string();
+
         let raw_duration = video_segment
             .split("#clock-o\"></use></svg>")
-            .collect::<Vec<&str>>()[1]
+            .nth(1)
-            .split("<")
+            .and_then(|s| s.split('<').next())
-            .collect::<Vec<&str>>()[0]
+            .unwrap_or("0:00");
-            .trim()
-            .to_string();
-        let duration = parse_time_to_seconds(raw_duration.as_str()).unwrap_or(0) as u32;
-        let views = parse_abbreviated_number( video_segment
-            .split("<use xlink:href=\"#eye\"></use></svg>")
-            .collect::<Vec<&str>>()[1]
-            .split("<")
-            .collect::<Vec<&str>>()[0]
-            .trim()).unwrap_or(0);
 
-        let formats = match self.extract_media(&video_url, requester.clone()).await{
+        let duration = parse_time_to_seconds(raw_duration).unwrap_or(0) as u32;
-            Some(f) => f,
+
-            None => return Err(Error::from("Failed to extract media formats")),
+        let views = video_segment
-        };
+            .split("#eye\"></use></svg>")
-        let video_item = VideoItem::new(
+            .nth(1)
+            .and_then(|s| s.split('<').next())
+            .and_then(|v| parse_abbreviated_number(v.trim()))
+            .unwrap_or(0);
+
+        let formats = self
+            .extract_media(&video_url, requester)
+            .await
+            .ok_or_else(|| Error::from("media extraction failed"))?;
+
+        Ok(
+            VideoItem::new(
                 id,
                 title,
                 video_url,
-            "noodlemagazine".to_string(),
+                "noodlemagazine".into(),
                 thumb,
                 duration,
             )
             .views(views)
-        .formats(formats)
+            .formats(formats),
-        ;
+        )
-        return Ok(video_item);
     }
 
-    async fn extract_media(&self, video_url: &String, mut requester: Requester) -> Option<Vec<VideoFormat>> {
+    async fn extract_media(
-        let text = requester.get(video_url, Some(Version::HTTP_2)).await.unwrap_or("".to_string());
+        &self,
-        if text.is_empty() {
+        video_url: &String,
-            return None;
+        mut requester: Requester,
-        }
+    ) -> Option<Vec<VideoFormat>> {
+        let text = requester
+            .get(video_url, Some(Version::HTTP_2))
+            .await
+            .unwrap_or_default();
+
+        let json_str = text
+            .split("window.playlist = ")
+            .nth(1)?
+            .split(';')
+            .next()?;
+
+        let json: serde_json::Value = serde_json::from_str(json_str).ok()?;
+        let sources = json["sources"].as_array()?;
+
         let mut formats = vec![];
-        let json_str = text.split("window.playlist = ")
+
-                .collect::<Vec<&str>>()[1]
+        for s in sources {
-                .split(";")
+            let file = s["file"].as_str()?.to_string();
-                .collect::<Vec<&str>>()[0];
+            let label = s["label"].as_str().unwrap_or("unknown").to_string();
-        let json: serde_json::Value = serde_json::from_str(json_str).unwrap();
+
-        let sources = json["sources"].as_array().unwrap();
+            formats.push(
-        for source in sources {
+                VideoFormat::new(file, label.clone(), "video/mp4".into())
-            let file = source["file"].as_str().unwrap().to_string();
-            let label = source["label"].as_str().unwrap_or("unknown").to_string();
-            let format = VideoFormat::new(
-                file,
-                label.clone(),
-                "video/mp4".to_string(),
-            )
                     .format_id(label.clone())
                     .format_note(label.clone())
-            .http_header("Referer".to_string(), video_url.clone())
+                    .http_header("Referer".into(), video_url.clone()),
-            ;
+            );
-            formats.push(format);
         }
-        return Some(formats.into_iter().rev().collect());
+
+        Some(formats.into_iter().rev().collect())
     }
 }
 
@@ -265,27 +286,23 @@ impl Provider for NoodlemagazineProvider {
         per_page: String,
         options: ServerOptions,
     ) -> Vec<VideoItem> {
-        let _ = per_page;
         let _ = pool;
-        let videos: std::result::Result<Vec<VideoItem>, Error> = match query {
+        let _ = per_page;
-            Some(q) => {
+
-                self.query(cache, page.parse::<u8>().unwrap_or(1), &q, options)
+        let page = page.parse::<u8>().unwrap_or(1);
-                    .await
+
-            }
+        let res = match query {
-            None => {
+            Some(q) => self.query(cache, page, &q, options).await,
-                self.get(cache, page.parse::<u8>().unwrap_or(1), &sort, options)
+            None => self.get(cache, page, &sort, options).await,
-                    .await
-            }
         };
-        match videos {
+
-            Ok(v) => v,
+        res.unwrap_or_else(|e| {
-            Err(e) => {
+            eprintln!("Noodlemagazine error: {e}");
-                println!("Error fetching videos: {}", e);
             vec![]
+        })
     }
-        }
+
-    }
+    fn get_channel(&self, clientversion: ClientVersion) -> Channel {
-    fn get_channel(&self, clientversion: ClientVersion) -> crate::status::Channel {
         self.build_channel(clientversion)
     }
 }