v2.1.1 - Better performance (#17)

* Improved performance A LOT. Other minor improvements

* Updated program version

Author: margual56

Cargo.lock

@@ -2,7 +2,7 @@
 authors = ["Marcos Gutiérrez Alonso <margual56@gmail.com>"]
 description = "A simple radio cli for listening to your favourite streams from the console"
 name = "radio-cli"
-version = "2.1.0"
+version = "2.1.1"
 edition = "2021"
 homepage = "https://github.com/margual56/radio-cli"
 repository = "https://github.com/margual56/radio-cli"

Cargo.toml

@@ -1,5 +1,5 @@
 {
-	"config_version": "2.1.0",
+	"config_version": "2.1.1",
 	"max_lines": 7,
 	"country": "ES",
 	"data": [

config.json

@@ -2,110 +2,109 @@ use std::error::Error;
 
 use crate::{station::Station, Config};
 use inquire::{error::InquireError, Text};
-use radiobrowser::{blocking::RadioBrowserAPI, ApiCountry, StationOrder};
+use radiobrowser::{blocking::RadioBrowserAPI, ApiCountry, ApiStation, StationOrder};
 
-pub fn get_countries() -> Result<Vec<ApiCountry>, Box<dyn Error>> {
-    let api = match RadioBrowserAPI::new() {
-        Ok(r) => r,
-        Err(_e) => panic!("Failed to create Radio Browser API!"),
-    };
-
-    api.get_countries().send()
+pub struct Browser {
+    api: RadioBrowserAPI,
+    config: Config,
+    stations: Vec<ApiStation>,
 }
 
-pub fn get_station(name: String, country_code: Option<String>) -> Result<Station, InquireError> {
-    let api = match RadioBrowserAPI::new() {
-        Ok(r) => r,
-        Err(_e) => panic!("Failed to create Radio Browser API!"),
-    };
+impl Browser {
+    pub fn new(config: Config) -> Result<Browser, Box<dyn Error>> {
+        let api = match RadioBrowserAPI::new() {
+            Ok(r) => r,
+            Err(e) => return Err(e),
+        };
 
-    if let Some(code) = country_code {
-        return match api.get_stations().name(name).countrycode(code).send() {
-            Ok(s) => match s.get(0) {
-                Some(x) => Ok(Station {
-                    station: x.name.clone(),
-                    url: x.url.clone(),
-                }),
-                None => Err(InquireError::InvalidConfiguration(
-                    "Radio station does not exist".to_string(),
-                )),
-            },
-            Err(_e) => Err(InquireError::OperationInterrupted),
+        let stations = if let Some(code) = &config.country_code {
+            match api
+                .get_stations()
+                .countrycode(code)
+                .order(StationOrder::Clickcount)
+                .send()
+            {
+                Ok(s) => s,
+                Err(_e) => Vec::new(),
+            }
+        } else {
+            match api.get_stations().order(StationOrder::Clickcount).send() {
+                Ok(s) => s,
+                Err(_e) => Vec::new(),
+            }
         };
-    } else {
-        return match api.get_stations().name(name).send() {
-            Ok(s) => match s.get(0) {
-                Some(x) => Ok(Station {
-                    station: x.name.clone(),
-                    url: x.url.clone(),
-                }),
-                None => Err(InquireError::InvalidConfiguration(
-                    "Radio station does not exist".to_string(),
-                )),
-            },
-            Err(_e) => Err(InquireError::OperationInterrupted),
+
+        Ok(Browser {
+            api,
+            config,
+            stations,
+        })
+    }
+
+    pub fn get_countries() -> Result<Vec<ApiCountry>, Box<dyn Error>> {
+        let api = match RadioBrowserAPI::new() {
+            Ok(r) => r,
+            Err(e) => return Err(e),
         };
+
+        api.get_countries().send()
     }
-}
 
-fn search_station(
-    message: &str,
-    placeholder: &str,
-    country_code: Option<String>,
-) -> Result<String, InquireError> {
-    let api = match RadioBrowserAPI::new() {
-        Ok(r) => r,
-        Err(_e) => panic!("Failed to create Radio Browser API!"),
-    };
+    pub fn get_station(&self, name: String) -> Result<Station, InquireError> {
+        if let Some(code) = self.config.country_code.clone() {
+            return match self.api.get_stations().name(name).countrycode(code).send() {
+                Ok(s) => match s.get(0) {
+                    Some(x) => Ok(Station {
+                        station: x.name.clone(),
+                        url: x.url.clone(),
+                    }),
+                    None => Err(InquireError::InvalidConfiguration(
+                        "Radio station does not exist".to_string(),
+                    )),
+                },
+                Err(_e) => Err(InquireError::OperationInterrupted),
+            };
+        } else {
+            return match self.api.get_stations().name(name).send() {
+                Ok(s) => match s.get(0) {
+                    Some(x) => Ok(Station {
+                        station: x.name.clone(),
+                        url: x.url.clone(),
+                    }),
+                    None => Err(InquireError::InvalidConfiguration(
+                        "Radio station does not exist".to_string(),
+                    )),
+                },
+                Err(_e) => Err(InquireError::OperationInterrupted),
+            };
+        }
+    }
 
-    Text::new(message)
-        .with_placeholder(placeholder)
-        .with_suggester(&|s: &str| {
-            if s.len() > 3 {
-                if let Some(code) = &country_code {
-                    match api
-                        .get_stations()
-                        .countrycode(code)
-                        .name(s)
-                        .order(StationOrder::Clickcount)
-                        .send()
-                    {
-                        Ok(s) => s
-                            .iter()
-                            .map(|station| String::from(&station.name))
-                            .collect(),
-                        Err(_e) => Vec::new(),
-                    }
-                } else {
-                    match api
-                        .get_stations()
-                        .name(s)
-                        .order(StationOrder::Clickcount)
-                        .send()
-                    {
-                        Ok(s) => s
-                            .iter()
-                            .map(|station| String::from(&station.name))
-                            .collect(),
-                        Err(_e) => Vec::new(),
-                    }
-                }
-            } else {
-                Vec::new()
-            }
-        })
-        .prompt()
-}
+    fn search_station(&self, message: &str, placeholder: &str) -> Result<String, InquireError> {
+        let max_lines = match self.config.max_lines {
+            Some(x) => x,
+            None => Text::DEFAULT_PAGE_SIZE,
+        };
+
+        Text::new(message)
+            .with_placeholder(placeholder)
+            .with_suggester(&|s: &str| {
+                self.stations
+                    .iter()
+                    .filter(|station| station.name.contains(s))
+                    .map(|station| String::from(&station.name))
+                    .collect()
+            })
+            .with_page_size(max_lines)
+            .prompt()
+    }
 
-pub fn prompt(config: Config) -> Result<Station, InquireError> {
-    let station = search_station(
-        "Search for a station: ",
-        "Station name",
-        config.country_code.clone(),
-    );
+    pub fn prompt(self) -> Result<Station, InquireError> {
+        let station = self.search_station("Search for a station: ", "Station name");
 
-    match station {
-        Ok(s) => get_station(s, config.country_code.clone()),
-        Err(e) => Err(e),
+        match station {
+            Ok(s) => self.get_station(s.to_string()),
+            Err(e) => Err(e),
+        }
     }
 }

src/lib/browser.rs

@@ -14,7 +14,7 @@ use std::fs::File;
 use std::io::{Read, Write};
 use std::path::PathBuf;
 
-use crate::browser;
+use crate::browser::Browser;
 
 const _CONFIG_URL: &str = "https://raw.githubusercontent.com/margual56/radio-cli/main/config.json";
 
@@ -154,31 +154,45 @@ impl Config {
         return stations;
     }
 
-    pub fn prompt(self) -> Result<Station, InquireError> {
+    /// Prompts the user to select a station.
+    /// Returns a station and if the station was taken from the internet.
+    pub fn prompt(self) -> Result<(Station, bool), InquireError> {
         let res: Result<Station, InquireError>;
-        if let Some(lines) = self.max_lines {
-            res = Select::new(&"Select a station to play:".bold(), self.data.clone())
-                .with_page_size(lines)
-                .prompt();
-        } else {
-            res = Select::new(&"Select a station to play:".bold(), self.data.clone()).prompt();
-        }
 
+        let max_lines: usize = match self.max_lines {
+            Some(x) => x,
+            None => Select::<Station>::DEFAULT_PAGE_SIZE,
+        };
+
+        res = Select::new(&"Select a station to play:".bold(), self.data.clone())
+            .with_page_size(max_lines)
+            .prompt();
+
+        let internet: bool;
         let station: Station = match res {
             Ok(s) => {
                 if s.station.eq("Other") {
-                    match browser::prompt(self) {
+                    internet = true;
+                    let result = Browser::new(self);
+
+                    let brow = match result {
+                        Ok(b) => b,
+                        Err(_e) => return Err(InquireError::OperationInterrupted),
+                    };
+
+                    match brow.prompt() {
                         Ok(r) => r,
                         Err(e) => return Err(e),
                     }
                 } else {
+                    internet = false;
                     s
                 }
             }
             Err(e) => return Err(e),
         };
 
-        return Ok(station);
+        return Ok((station, internet));
     }
 }
 

src/lib/config.rs

@@ -1,6 +1,7 @@
 pub use clap::Parser;
 use colored::*;
-use radio_libs::{browser, perror, Config, ConfigError, Station, Version};
+use radio_libs::browser::Browser;
+use radio_libs::{perror, Config, ConfigError, Station, Version};
 use std::io::Write;
 use std::path::PathBuf;
 use std::process::{Command, Stdio};
@@ -78,9 +79,7 @@ fn main() {
     let args = Cli::parse();
 
     if args.list_countries {
-        let result = browser::get_countries();
-
-        if let Ok(countries) = result {
+        if let Ok(countries) = Browser::get_countries() {
             for country in countries {
                 println!("{}: \"{}\"", country.name, country.iso_3166_1.bold());
             }
@@ -177,7 +176,20 @@ fn main() {
 
                             internet = true;
 
-                            match browser::get_station(x.clone(), config.country_code.clone()) {
+                            let brows = match Browser::new(config) {
+                                Ok(b) => b,
+                                Err(e) => {
+                                    perror("Could not connect with the API");
+
+                                    if args.debug {
+                                        println!("{}", e);
+                                    }
+
+                                    std::process::exit(1);
+                                }
+                            };
+
+                            match brows.get_station(x.clone()) {
                                 Ok(s) => s.url,
                                 Err(e) => {
                                     perror("This station was not found :(");
@@ -199,7 +211,10 @@ fn main() {
                 None => {
                     // And let the user choose one
                     match config.clone().prompt() {
-                        Ok(s) => s,
+                        Ok((s, b)) => {
+                            internet = b;
+                            s
+                        }
                         Err(error) => {
                             println!("\n\t{}", "Bye!".bold().green());