V2.0.0 - Big changes! (#8)

* New and improved config file with room for adding more optional settings in the future
* New `version` field in the config, to display warnings when breaking changes are introduced
* New `max_lines` optional field in the config, to change the maximum number of options shown at once
* Optimized parsing, now it's blazing fast!
* Optimized (a lot) the station searching algorithm
* Added the CLI option `-c` or `--config` to specify the config file to use
* Added the CLI option `-d` or `--debug` to separate verbose and debug messages
* Reorganized a bit the project structure, for more easy development (although there is some tidying needed in the main function)
* Fixed exit error codes being wrong (#7 )
* Changed from `--no-video` to `--show-video` (so now the default is to **not** show the video)
* And more!

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 = "1.0.1"
+version = "2.0.0"
 edition = "2021"
 homepage = "https://github.com/margual56/radio-cli"
 repository = "https://github.com/margual56/radio-cli"

Cargo.toml

@@ -1,4 +1,6 @@
 {
+	"config_version": "2.0.0",
+	"max_lines": 7,
 	"data": [
 		{
 			"station": "Los 40 Principales",
@@ -25,4 +27,4 @@
 			"url": "https://www.youtube.com/watch?v=5qap5aO4i9A"
 		}
 	]
-}
+}

config.json

@@ -0,0 +1,174 @@
+extern crate xdg;
+
+use crate::station::Station;
+use crate::version::Version;
+use crate::errors::{ConfigError, ConfigErrorCode};
+use crate::perror;
+
+use serde::{Deserialize};
+use serde::de::{Deserializer, Visitor, Error as SeError};
+use std::fs::File; 
+use std::io::{Write, Read};
+use std::path::PathBuf;
+use inquire::{error::InquireError, Select};
+use std::fmt::{Formatter, Result as ResultFmt};
+use colored::*;
+
+const _CONFIG_URL: &str = "https://raw.githubusercontent.com/margual56/radio-cli/main/config.json";
+
+#[derive(Deserialize, Debug, Clone)]
+pub struct Config {
+    #[serde(deserialize_with = "deserialize_version")]
+	pub config_version: Version,
+	pub max_lines: Option<usize>,
+	pub data: Vec<Station>
+}
+
+impl Config {
+	pub fn load_default() -> Result<Config, ConfigError> {
+		// Load config.json from $XDG_CONFIG_HOME/radio-cli
+		let xdg_dirs = xdg::BaseDirectories::with_prefix("radio-cli").unwrap();
+		let config_file = Config::load_config(xdg_dirs);
+
+		Config::load(config_file)		
+	}
+
+	pub fn load_from_file(path: PathBuf) -> Result<Config, ConfigError> {
+		Config::load(path)
+	}
+
+	fn load(file: PathBuf) -> Result<Config, ConfigError> {
+		let mut config_file = match File::open(file.to_path_buf()) {
+			Ok(x) => x,
+			Err(error) => 
+				return Err(ConfigError {
+					code: ConfigErrorCode::OpenError,
+					message: format!("Could not open the file {:?}", file),
+					extra: format!("{:?}", error),
+				})
+		};
+
+		// Read and parse the config into the `cfg` variable
+		let mut config: String = String::new();
+		match config_file.read_to_string(&mut config) {
+			Ok(_) => {},
+			Err(error) => 
+				return Err(ConfigError {
+					code: ConfigErrorCode::ReadError,
+					message: format!("Couldn't read the file {:?}", file),
+					extra: format!("{:?}", error),
+				})
+		}
+
+		let data: Config = match serde_json::from_str(&config) {
+			Ok(x) => x,
+			Err(error) => 
+				return Err(ConfigError {
+					code: ConfigErrorCode::ParseError,
+					message: format!("Couldn't parse config"),
+					extra: format!("{:?}", error),
+				})
+		};
+
+		Ok(data)
+	}
+
+	fn load_config(dir: xdg::BaseDirectories) -> PathBuf {
+		match dir.find_config_file("config.json") {
+			None => {
+				// Get the name of the directory
+				let tmp = dir.get_config_file("");
+				let dir_name: &str = match tmp.to_str() {
+					Some(x) => x,
+					None => "??"
+				};
+
+				// Print an error message
+				let msg = format!("The config file does not exist in \"{}\"", dir_name);
+				perror(msg.as_str());
+
+				// Download the file
+				println!("\tLoading file from {}...", _CONFIG_URL.italic());
+				let resp = reqwest::blocking::get(_CONFIG_URL).expect("Request failed");
+				let body = resp.text().expect("Body invalid");
+
+				// Create the new config file
+				let file_ref = dir.place_config_file("config.json").expect("Could not create config file");
+
+				println!("\tDone loading!");
+
+				println!("\tTrying to open {} to write the config...", file_ref.to_str().expect("msg: &str").bold());
+
+				let mut file = File::create(file_ref.clone()).unwrap();	// This is write-only!!
+				file.write_all(body.as_bytes()).expect("Could not write to config");
+
+				drop(file); // So we close the file to be able to read it
+
+				println!("\tFinished writing config. Enjoy! :)\n\n");
+
+				file_ref
+			},
+			Some(x) => x
+		}
+	}
+
+	pub fn get_url_for(self, station_name: &str) -> Option<String> {
+		for s in self.data.iter() {
+			if s.station.eq(station_name) {
+				return Some(s.url.clone());
+			}
+		}
+
+		None
+	}
+
+	pub fn get_all_stations(self) -> Vec<String> {
+		let mut stations: Vec<String> = Vec::new();
+
+		for s in self.data.iter() {
+			stations.push(s.station.clone());
+		}
+
+		return stations;
+	}
+
+	pub fn prompt(self) -> Result<Station, InquireError> {
+        if let Some(lines) = self.max_lines {
+            Select
+                ::new(&"Select a station to play:".bold(), self.data)
+                .with_page_size(lines)
+                .prompt()
+        }else{
+            Select
+                ::new(&"Select a station to play:".bold(), self.data)
+                .prompt()
+        }
+	}
+}
+
+fn deserialize_version<'de, D>(deserializer: D) -> Result<Version, D::Error> where D: Deserializer<'de>, {
+    struct JsonStringVisitor;
+
+    impl<'de> Visitor<'de> for JsonStringVisitor {
+        type Value = Version;
+    
+        fn expecting(&self, formatter: &mut Formatter) -> ResultFmt {
+            formatter.write_str("a string")
+        }
+    
+        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+        where
+            E: SeError,
+        {
+            // unfortunately we lose some typed information
+            // from errors deserializing the json string
+            match Version::from(String::from(v)) {
+				Some(x) => Ok(x),
+				None => Err(SeError::custom("Could not parse version"))
+			}
+        }
+    }
+    
+    // use our visitor to deserialize an `ActualValue`
+    deserializer.deserialize_any(JsonStringVisitor)
+}

src/lib/config.rs

@@ -0,0 +1,29 @@
+use std::fmt::{Display, Debug, Formatter, Result};
+
+#[derive(Debug)]
+pub enum ConfigErrorCode {
+    OpenError,
+    ReadError,
+    CloseError,
+    ParseError,
+}
+
+pub struct ConfigError {
+    pub code: ConfigErrorCode,
+    pub message: String,
+    pub extra: String,
+}
+
+// Implement std::fmt::Display for ConfigError
+impl Display for ConfigError {
+    fn fmt(&self, f: &mut Formatter) -> Result {
+        write!(f, "{}", self.message) // user-facing output
+    }
+}
+
+// Implement std::fmt::Debug for ConfigError
+impl Debug for ConfigError {
+    fn fmt(&self, f: &mut Formatter) -> Result {
+        write!(f, "{{ code: {:?}, message: \"{}\", info: {} }}", self.code, self.message, self.extra) // programmer-facing output
+    }
+}

src/lib/errors.rs

@@ -1,108 +1,14 @@
-extern crate xdg;
+mod errors;
+mod station;
+mod version;
+mod config;
 
-use serde::{Deserialize};
-use std::fs::File; 
-use std::io::Write;
-use std::io::Read;
-use inquire::{error::InquireError, Select};
-use colored::*;
-
-pub const CONFIG_URL: &str = "https://raw.githubusercontent.com/margual56/radio-cli/main/config.json";
-
-#[derive(Deserialize, Debug, Clone)]
-pub struct Station {
-	pub station: String,
-	pub url: String
-}
-
-#[derive(Deserialize, Debug, Clone)]
-pub struct Config {
-	data: Vec<Station>
-}
-
-impl Config {
-	pub fn load() -> Config {
-		// Load config.json from $XDG_CONFIG_HOME/radio-cli
-		let xdg_dirs = xdg::BaseDirectories::with_prefix("radio-cli").unwrap();
-		let mut config_file = Config::load_config(xdg_dirs);
-
-		// Read and parse the config into the `cfg` variable
-		let mut config: String = String::new();
-		config_file.read_to_string(&mut config).expect("Couldn't read config");
-
-		Config {
-			data: serde_json::from_str::<Config>(&config).expect("Couldn't parse config").data,
-		}
-	}
-
-	fn load_config(dir: xdg::BaseDirectories) -> std::fs::File {
-		match dir.find_config_file("config.json") {
-			None => {
-				// Get the name of the directory
-				let tmp = dir.get_config_file("");
-				let dir_name: &str = match tmp.to_str() {
-					Some(x) => x,
-					None => "??"
-				};
-
-				// Print an error message
-				let msg = format!("The config file does not exist in \"{}\"", dir_name);
-				perror(msg.as_str());
-
-				// Download the file
-				println!("\tLoading file from {}...", CONFIG_URL.italic());
-				let resp = reqwest::blocking::get(CONFIG_URL).expect("Request failed");
-				let body = resp.text().expect("Body invalid");
-
-				// Create the new config file
-				let file_ref = dir.place_config_file("config.json").expect("Could not create config file");
-
-				println!("\tDone loading!");
+pub use station::Station;
+pub use version::Version;
+pub use errors::{ConfigError, ConfigErrorCode};
+pub use config::Config;
 
-				println!("\tTrying to open {} to write the config...", file_ref.to_str().expect("msg: &str").bold());
-
-				let mut file = File::create(file_ref.clone()).unwrap();	// This is write-only!!
-				file.write_all(body.as_bytes()).expect("Could not write to config");
-
-				drop(file); // So we close the file to be able to read it
-
-				println!("\tFinished writing config. Enjoy! :)\n\n");
-
-				File::open(file_ref).unwrap()  // This is read-only
-			},
-			Some(x) => File::open(x).expect("Could not open config")
-		}
-	}
-
-	pub fn get_url_for(self, station_name: &str) -> Result<String, ()> {
-		for s in self.data.iter() {
-			if s.station.eq(station_name) {
-				return Ok(s.url.clone());
-			}
-		}
-
-		Err(())
-	}
-
-	pub fn get_all_stations(self) -> Vec<String> {
-		let mut stations: Vec<String> = Vec::new();
-
-		for s in self.data.iter() {
-			stations.push(s.station.clone());
-		}
-
-		return stations;
-	}
-
-	pub fn prompt(self, options: Vec<String>) -> Result<String, InquireError> {
-		let res: Result<&str, InquireError> = Select::new(&"Select a station to play:".bold(), options.iter().map(|s| s.as_ref()).collect()).prompt();
-		
-		match res {
-			Ok(s) => Ok(s.to_string()),
-			Err(error) => Err(error)
-		}
-	}
-}
+use colored::*;
 
 pub fn perror(msg: &str) {
 	println!("{} {}", "Error:".red().bold(), msg);

src/lib/lib.rs

@@ -0,0 +1,12 @@
+use serde::Deserialize;
+#[derive(Deserialize, Debug, Clone)]
+pub struct Station {
+	pub station: String,
+	pub url: String
+}
+
+impl std::fmt::Display for Station {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.station)
+    }
+}