From 34b71dd0095b0310036e50eaf9fb8690507319b3 Mon Sep 17 00:00:00 2001 From: ad4mx Date: Mon, 18 Jul 2022 10:12:34 +0200 Subject: [PATCH 1/4] Added coloring on spinners --- Cargo.toml | 1 + examples/cycle.rs | 4 ++-- examples/simple.rs | 3 ++- examples/stop_persist.rs | 1 + examples/stop_symbol.rs | 1 + examples/timer.rs | 3 ++- src/lib.rs | 23 ++++++++++++----------- src/utils/color.rs | 23 +++++++++++++++++++++++ src/utils/mod.rs | 1 + 9 files changed, 45 insertions(+), 15 deletions(-) create mode 100644 src/utils/color.rs diff --git a/Cargo.toml b/Cargo.toml index d318b89..f3e3875 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -17,3 +17,4 @@ include = ["src/**/*", "README.md"] lazy_static = { version = "1.4.0" } maplit = { version = "1.0.2" } strum = { version = "0.24.0", features = ["derive"] } +yansi = { version = "0.5.1" } diff --git a/examples/cycle.rs b/examples/cycle.rs index d5f7ae8..61fd7bc 100644 --- a/examples/cycle.rs +++ b/examples/cycle.rs @@ -1,11 +1,11 @@ -use spinners::{Spinner, Spinners}; +use spinners::{Spinner, Spinners, Color}; use std::{thread::sleep, time::Duration}; use strum::IntoEnumIterator; fn main() { // loop through each spinner and display them for 2 seconds for spinner in Spinners::iter() { - let mut sp = Spinner::new(spinner.clone(), format!("{:?}", spinner)); + let mut sp = Spinner::new(spinner.clone(), format!("{:?}", spinner), Some(Color::Blue)); sleep(Duration::from_secs(2)); sp.stop(); } diff --git a/examples/simple.rs b/examples/simple.rs index 9803d55..971a225 100644 --- a/examples/simple.rs +++ b/examples/simple.rs @@ -1,4 +1,4 @@ -use spinners::{Spinner, Spinners}; +use spinners::{Color, Spinner, Spinners}; use std::{env, str::FromStr, thread::sleep, time::Duration}; fn main() { @@ -8,6 +8,7 @@ fn main() { let mut sp = Spinner::new( Spinners::from_str(&spinner_name).unwrap(), "Waiting for 3 seconds".into(), + Some(Color::Green), ); sleep(Duration::from_secs(3)); sp.stop_with_message("Finishing waiting for 3 seconds\n".into()); diff --git a/examples/stop_persist.rs b/examples/stop_persist.rs index 09f16ee..373641d 100644 --- a/examples/stop_persist.rs +++ b/examples/stop_persist.rs @@ -8,6 +8,7 @@ fn main() { let mut sp = Spinner::new( Spinners::from_str(&spinner_name).unwrap(), "Waiting for 3 seconds".into(), + None, ); sleep(Duration::from_secs(3)); sp.stop_and_persist("✔", "That worked!".to_string()) diff --git a/examples/stop_symbol.rs b/examples/stop_symbol.rs index 60d0539..8662dc8 100644 --- a/examples/stop_symbol.rs +++ b/examples/stop_symbol.rs @@ -8,6 +8,7 @@ fn main() { let mut sp = Spinner::new( Spinners::from_str(&spinner_name).unwrap(), "Waiting for 3 seconds".into(), + None, ); sleep(Duration::from_secs(3)); sp.stop_with_symbol("\x1b[32m🗸\x1b[0m"); diff --git a/examples/timer.rs b/examples/timer.rs index d7d5ec1..4c48a5b 100644 --- a/examples/timer.rs +++ b/examples/timer.rs @@ -1,4 +1,4 @@ -use spinners::{Spinner, Spinners}; +use spinners::{Spinner, Spinners, Color}; use std::{env, str::FromStr, thread::sleep, time::Duration}; fn main() { @@ -8,6 +8,7 @@ fn main() { let mut sp = Spinner::with_timer( Spinners::from_str(&spinner_name).unwrap(), "Waiting for 3 seconds".into(), + None, ); sleep(Duration::from_secs(3)); sp.stop_with_newline(); diff --git a/src/lib.rs b/src/lib.rs index 05d07cb..8179d4d 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -9,7 +9,8 @@ use std::{ pub use crate::utils::spinner_names::SpinnerNames as Spinners; use crate::utils::spinners_data::SPINNERS as SpinnersMap; - +pub use crate::utils::color::Color; +use crate::utils::color::colorize; mod utils; pub struct Spinner { @@ -34,9 +35,9 @@ impl Spinner { /// Basic Usage: /// /// ``` - /// use spinners::{Spinner, Spinners}; + /// use spinners::{Spinner, Spinners, Color}; /// - /// let sp = Spinner::new(Spinners::Dots, "Loading things into memory...".into()); + /// let sp = Spinner::new(Spinners::Dots, "Loading things into memory...".into(), Some(Color::Blue)); /// ``` /// /// No Message: @@ -44,18 +45,18 @@ impl Spinner { /// ``` /// use spinners::{Spinner, Spinners}; /// - /// let sp = Spinner::new(Spinners::Dots, String::new()); + /// let sp = Spinner::new(Spinners::Dots, String::new(), None); /// ``` - pub fn new(spinner: Spinners, message: String) -> Self { - Self::new_inner(spinner, message, None) + pub fn new(spinner: Spinners, message: String, color: Option) -> Self { + Self::new_inner(spinner, message, color, None) } /// Create a new spinner that logs the time since it was created - pub fn with_timer(spinner: Spinners, message: String) -> Self { - Self::new_inner(spinner, message, Some(Instant::now())) + pub fn with_timer(spinner: Spinners, message: String, color: Option) -> Self { + Self::new_inner(spinner, message, color, Some(Instant::now())) } - fn new_inner(spinner: Spinners, message: String, start_time: Option) -> Self { + fn new_inner(spinner: Spinners, message: String, color: Option, start_time: Option) -> Self { let spinner_name = spinner.to_string(); let spinner_data = SpinnersMap .get(&spinner_name) @@ -75,12 +76,12 @@ impl Spinner { let frame = stop_symbol.unwrap_or_else(|| frame.to_string()); match start_time { None => { - print!("\r{} {}", frame, message); + print!("\r{} {}", colorize(frame, color), message); } Some(start_time) => { let now = stop_time.unwrap_or_else(Instant::now); let duration = now.duration_since(start_time).as_secs_f64(); - print!("\r{}{:>10.3} s\t{}", frame, duration, message); + print!("\r{}{:>10.3} s\t{}", colorize(frame, color), duration, message); } } diff --git a/src/utils/color.rs b/src/utils/color.rs new file mode 100644 index 0000000..789f14b --- /dev/null +++ b/src/utils/color.rs @@ -0,0 +1,23 @@ +use yansi::Paint; + +#[derive(Debug, Clone, Copy)] +pub enum Color { + Blue, + Green, + Red, + Yellow, + Cyan, + White, +} + +pub fn colorize(input: String, color: Option) -> Paint { + match color { + Some(Color::Blue) => Paint::blue(input), + Some(Color::Green) => Paint::green(input), + Some(Color::Red) => Paint::red(input), + Some(Color::Yellow) => Paint::yellow(input), + Some(Color::Cyan) => Paint::cyan(input), + Some(Color::White) => Paint::new(input), + None => Paint::new(input), + } +} diff --git a/src/utils/mod.rs b/src/utils/mod.rs index 759a102..4b87218 100644 --- a/src/utils/mod.rs +++ b/src/utils/mod.rs @@ -1,3 +1,4 @@ +pub mod color; pub mod spinner_data; pub mod spinner_names; pub mod spinners_data; From ff318155876b4538979cbde1273a1398a8ee48fc Mon Sep 17 00:00:00 2001 From: ad4mx Date: Mon, 18 Jul 2022 10:15:22 +0200 Subject: [PATCH 2/4] Fixed bugs --- examples/timer.rs | 2 +- src/lib.rs | 12 ++++++------ 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/examples/timer.rs b/examples/timer.rs index 4c48a5b..03d35bd 100644 --- a/examples/timer.rs +++ b/examples/timer.rs @@ -1,4 +1,4 @@ -use spinners::{Spinner, Spinners, Color}; +use spinners::{Spinner, Spinners}; use std::{env, str::FromStr, thread::sleep, time::Duration}; fn main() { diff --git a/src/lib.rs b/src/lib.rs index 8179d4d..eef71d6 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -119,7 +119,7 @@ impl Spinner { /// ``` /// use spinners::{Spinner, Spinners}; /// - /// let mut sp = Spinner::new(Spinners::Dots, "Loading things into memory...".into()); + /// let mut sp = Spinner::new(Spinners::Dots, "Loading things into memory...".into(), None); /// /// sp.stop(); /// ``` @@ -138,7 +138,7 @@ impl Spinner { /// ``` /// use spinners::{Spinner, Spinners}; /// - /// let mut sp = Spinner::new(Spinners::Dots, "Loading things into memory...".into()); + /// let mut sp = Spinner::new(Spinners::Dots, "Loading things into memory...".into(), None); /// /// sp.stop_with_symbol("🗸"); /// ``` @@ -148,7 +148,7 @@ impl Spinner { /// ``` /// use spinners::{Spinner, Spinners}; /// - /// let mut sp = Spinner::new(Spinners::Dots, "Loading things into memory...".into()); + /// let mut sp = Spinner::new(Spinners::Dots, "Loading things into memory...".into(), None); /// /// sp.stop_with_symbol("\x1b[32m🗸\x1b[0m"); /// ``` @@ -166,7 +166,7 @@ impl Spinner { /// ``` /// use spinners::{Spinner, Spinners}; /// - /// let mut sp = Spinner::new(Spinners::Dots, "Loading things into memory...".into()); + /// let mut sp = Spinner::new(Spinners::Dots, "Loading things into memory...".into(), None); /// /// sp.stop_with_newline(); /// ``` @@ -184,7 +184,7 @@ impl Spinner { /// ``` /// use spinners::{Spinner, Spinners}; /// - /// let mut sp = Spinner::new(Spinners::Dots, "Loading things into memory...".into()); + /// let mut sp = Spinner::new(Spinners::Dots, "Loading things into memory...".into(), None); /// /// sp.stop_with_message("Finished loading things into memory!".into()); /// ``` @@ -202,7 +202,7 @@ impl Spinner { /// ``` /// use spinners::{Spinner, Spinners}; /// - /// let mut sp = Spinner::new(Spinners::Dots, "Loading things into memory...".into()); + /// let mut sp = Spinner::new(Spinners::Dots, "Loading things into memory...".into(), None); /// /// sp.stop_and_persist("✔", "Finished loading things into memory!".into()); /// ``` From b1604c5c58718788eef09e104b4c7399abbacd14 Mon Sep 17 00:00:00 2001 From: ad4mx Date: Sat, 23 Jul 2022 14:59:12 +0200 Subject: [PATCH 3/4] removed the need for wrapping in Some() --- README.md | 2 +- examples/cycle.rs | 4 ++-- examples/simple.rs | 2 +- src/lib.rs | 13 ++++++++----- src/utils/color.rs | 4 ++++ 5 files changed, 16 insertions(+), 9 deletions(-) diff --git a/README.md b/README.md index e2e7335..cd990b0 100644 --- a/README.md +++ b/README.md @@ -22,7 +22,7 @@ use std::thread::sleep; use std::time::Duration; fn main() { - let mut sp = Spinner::new(Spinners::Dots9, "Waiting for 3 seconds".into()); + let mut sp = Spinner::new(Spinners::Dots9, "Waiting for 3 seconds".into(), None); sleep(Duration::from_secs(3)); sp.stop(); } diff --git a/examples/cycle.rs b/examples/cycle.rs index 61fd7bc..054cd45 100644 --- a/examples/cycle.rs +++ b/examples/cycle.rs @@ -1,11 +1,11 @@ -use spinners::{Spinner, Spinners, Color}; +use spinners::{Spinner, Spinners}; use std::{thread::sleep, time::Duration}; use strum::IntoEnumIterator; fn main() { // loop through each spinner and display them for 2 seconds for spinner in Spinners::iter() { - let mut sp = Spinner::new(spinner.clone(), format!("{:?}", spinner), Some(Color::Blue)); + let mut sp = Spinner::new(spinner.clone(), format!("{:?}", spinner), None); sleep(Duration::from_secs(2)); sp.stop(); } diff --git a/examples/simple.rs b/examples/simple.rs index 971a225..e472c5b 100644 --- a/examples/simple.rs +++ b/examples/simple.rs @@ -8,7 +8,7 @@ fn main() { let mut sp = Spinner::new( Spinners::from_str(&spinner_name).unwrap(), "Waiting for 3 seconds".into(), - Some(Color::Green), + Color::Green, ); sleep(Duration::from_secs(3)); sp.stop_with_message("Finishing waiting for 3 seconds\n".into()); diff --git a/src/lib.rs b/src/lib.rs index eef71d6..d61d4e0 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -47,16 +47,19 @@ impl Spinner { /// /// let sp = Spinner::new(Spinners::Dots, String::new(), None); /// ``` - pub fn new(spinner: Spinners, message: String, color: Option) -> Self { + pub fn new(spinner: Spinners, message: String, color: T) -> Self + where T: Into> + std::marker::Send + 'static + std::marker::Copy { Self::new_inner(spinner, message, color, None) } /// Create a new spinner that logs the time since it was created - pub fn with_timer(spinner: Spinners, message: String, color: Option) -> Self { + pub fn with_timer(spinner: Spinners, message: String, color: T) -> Self + where T: Into> + std::marker::Send + 'static + std::marker::Copy { Self::new_inner(spinner, message, color, Some(Instant::now())) } - fn new_inner(spinner: Spinners, message: String, color: Option, start_time: Option) -> Self { + fn new_inner(spinner: Spinners, message: String, color: T, start_time: Option) -> Self + where T: Into> + std::marker::Send + 'static + std::marker::Copy { let spinner_name = spinner.to_string(); let spinner_data = SpinnersMap .get(&spinner_name) @@ -76,12 +79,12 @@ impl Spinner { let frame = stop_symbol.unwrap_or_else(|| frame.to_string()); match start_time { None => { - print!("\r{} {}", colorize(frame, color), message); + print!("\r{} {}", colorize(frame, color.into()), message); } Some(start_time) => { let now = stop_time.unwrap_or_else(Instant::now); let duration = now.duration_since(start_time).as_secs_f64(); - print!("\r{}{:>10.3} s\t{}", colorize(frame, color), duration, message); + print!("\r{}{:>10.3} s\t{}", colorize(frame, color.into()), duration, message); } } diff --git a/src/utils/color.rs b/src/utils/color.rs index 789f14b..0c61042 100644 --- a/src/utils/color.rs +++ b/src/utils/color.rs @@ -8,6 +8,8 @@ pub enum Color { Yellow, Cyan, White, + Magenta, + Black, } pub fn colorize(input: String, color: Option) -> Paint { @@ -18,6 +20,8 @@ pub fn colorize(input: String, color: Option) -> Paint { Some(Color::Yellow) => Paint::yellow(input), Some(Color::Cyan) => Paint::cyan(input), Some(Color::White) => Paint::new(input), + Some(Color::Magenta) => Paint::magenta(input), + Some(Color::Black) => Paint::black(input), None => Paint::new(input), } } From dfc625d8e694b78c5a1a4e3261c02923acc11062 Mon Sep 17 00:00:00 2001 From: ad4mx Date: Thu, 28 Jul 2022 21:46:33 +0200 Subject: [PATCH 4/4] moved to seperate function --- examples/color.rs | 12 ++++++++++ examples/cycle.rs | 2 +- examples/simple.rs | 3 +-- examples/stop_persist.rs | 3 +-- examples/stop_symbol.rs | 1 - src/lib.rs | 48 ++++++++++++++++++++++++++++---------- src/utils/color.rs | 2 +- src/utils/spinner_names.rs | 2 +- 8 files changed, 53 insertions(+), 20 deletions(-) create mode 100644 examples/color.rs diff --git a/examples/color.rs b/examples/color.rs new file mode 100644 index 0000000..e9a0cf2 --- /dev/null +++ b/examples/color.rs @@ -0,0 +1,12 @@ +use spinners::{Color, Spinner, Spinners}; +use std::{thread::sleep, time::Duration}; + +fn main() { + let mut sp = Spinner::new_with_color( + Spinners::Dots9, + "Waiting for 3 seconds".into(), + Color::Green, + ); + sleep(Duration::from_secs(3)); + sp.stop_with_message("Finishing waiting for 3 seconds".into()); +} diff --git a/examples/cycle.rs b/examples/cycle.rs index 054cd45..079a482 100644 --- a/examples/cycle.rs +++ b/examples/cycle.rs @@ -5,7 +5,7 @@ use strum::IntoEnumIterator; fn main() { // loop through each spinner and display them for 2 seconds for spinner in Spinners::iter() { - let mut sp = Spinner::new(spinner.clone(), format!("{:?}", spinner), None); + let mut sp = Spinner::new(spinner, format!("{:?}", spinner)); sleep(Duration::from_secs(2)); sp.stop(); } diff --git a/examples/simple.rs b/examples/simple.rs index e472c5b..9803d55 100644 --- a/examples/simple.rs +++ b/examples/simple.rs @@ -1,4 +1,4 @@ -use spinners::{Color, Spinner, Spinners}; +use spinners::{Spinner, Spinners}; use std::{env, str::FromStr, thread::sleep, time::Duration}; fn main() { @@ -8,7 +8,6 @@ fn main() { let mut sp = Spinner::new( Spinners::from_str(&spinner_name).unwrap(), "Waiting for 3 seconds".into(), - Color::Green, ); sleep(Duration::from_secs(3)); sp.stop_with_message("Finishing waiting for 3 seconds\n".into()); diff --git a/examples/stop_persist.rs b/examples/stop_persist.rs index 373641d..d00a472 100644 --- a/examples/stop_persist.rs +++ b/examples/stop_persist.rs @@ -8,8 +8,7 @@ fn main() { let mut sp = Spinner::new( Spinners::from_str(&spinner_name).unwrap(), "Waiting for 3 seconds".into(), - None, ); sleep(Duration::from_secs(3)); - sp.stop_and_persist("✔", "That worked!".to_string()) + sp.stop_and_persist("✔", "That worked!".to_string()); } diff --git a/examples/stop_symbol.rs b/examples/stop_symbol.rs index 8662dc8..60d0539 100644 --- a/examples/stop_symbol.rs +++ b/examples/stop_symbol.rs @@ -8,7 +8,6 @@ fn main() { let mut sp = Spinner::new( Spinners::from_str(&spinner_name).unwrap(), "Waiting for 3 seconds".into(), - None, ); sleep(Duration::from_secs(3)); sp.stop_with_symbol("\x1b[32m🗸\x1b[0m"); diff --git a/src/lib.rs b/src/lib.rs index d61d4e0..28d6b8b 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -35,9 +35,33 @@ impl Spinner { /// Basic Usage: /// /// ``` + /// use spinners::{Spinner, Spinners}; + /// + /// let sp = Spinner::new(Spinners::Dots, "Loading things into memory...".into()); + /// ``` + /// + /// No Message: + /// + /// ``` + /// use spinners::{Spinner, Spinners}; + /// + /// let sp = Spinner::new(Spinners::Dots, String::new()); + /// ``` + #[must_use] + pub fn new(spinner: Spinners, message: String) -> Self { + Self::new_inner(spinner, message, None, None) + } + + /// Create a new colored spinner along with a message + /// + /// # Examples + /// + /// Basic Usage: + /// + /// ``` /// use spinners::{Spinner, Spinners, Color}; /// - /// let sp = Spinner::new(Spinners::Dots, "Loading things into memory...".into(), Some(Color::Blue)); + /// let sp = Spinner::new_with_color(Spinners::Dots, "Loading things into memory...".into(), Color::Blue); /// ``` /// /// No Message: @@ -45,9 +69,9 @@ impl Spinner { /// ``` /// use spinners::{Spinner, Spinners}; /// - /// let sp = Spinner::new(Spinners::Dots, String::new(), None); + /// let sp = Spinner::new_with_color(Spinners::Dots, String::new(), None); /// ``` - pub fn new(spinner: Spinners, message: String, color: T) -> Self + pub fn new_with_color(spinner: Spinners, message: String, color: T) -> Self where T: Into> + std::marker::Send + 'static + std::marker::Copy { Self::new_inner(spinner, message, color, None) } @@ -69,14 +93,14 @@ impl Spinner { let join = thread::spawn(move || 'outer: loop { let mut stdout = stdout(); - for frame in spinner_data.frames.iter() { + for frame in &spinner_data.frames { let (do_stop, stop_time, stop_symbol) = match recv.try_recv() { Ok((stop_time, stop_symbol)) => (true, Some(stop_time), stop_symbol), Err(TryRecvError::Disconnected) => (true, None, None), Err(TryRecvError::Empty) => (false, None, None), }; - let frame = stop_symbol.unwrap_or_else(|| frame.to_string()); + let frame = stop_symbol.unwrap_or_else(|| (*frame).to_string()); match start_time { None => { print!("\r{} {}", colorize(frame, color.into()), message); @@ -94,7 +118,7 @@ impl Spinner { break 'outer; } - thread::sleep(Duration::from_millis(spinner_data.interval as u64)); + thread::sleep(Duration::from_millis(u64::from(spinner_data.interval))); } }); @@ -122,7 +146,7 @@ impl Spinner { /// ``` /// use spinners::{Spinner, Spinners}; /// - /// let mut sp = Spinner::new(Spinners::Dots, "Loading things into memory...".into(), None); + /// let mut sp = Spinner::new(Spinners::Dots, "Loading things into memory...".into()); /// /// sp.stop(); /// ``` @@ -141,7 +165,7 @@ impl Spinner { /// ``` /// use spinners::{Spinner, Spinners}; /// - /// let mut sp = Spinner::new(Spinners::Dots, "Loading things into memory...".into(), None); + /// let mut sp = Spinner::new(Spinners::Dots, "Loading things into memory...".into()); /// /// sp.stop_with_symbol("🗸"); /// ``` @@ -151,7 +175,7 @@ impl Spinner { /// ``` /// use spinners::{Spinner, Spinners}; /// - /// let mut sp = Spinner::new(Spinners::Dots, "Loading things into memory...".into(), None); + /// let mut sp = Spinner::new(Spinners::Dots, "Loading things into memory...".into()); /// /// sp.stop_with_symbol("\x1b[32m🗸\x1b[0m"); /// ``` @@ -169,7 +193,7 @@ impl Spinner { /// ``` /// use spinners::{Spinner, Spinners}; /// - /// let mut sp = Spinner::new(Spinners::Dots, "Loading things into memory...".into(), None); + /// let mut sp = Spinner::new(Spinners::Dots, "Loading things into memory...".into()); /// /// sp.stop_with_newline(); /// ``` @@ -187,7 +211,7 @@ impl Spinner { /// ``` /// use spinners::{Spinner, Spinners}; /// - /// let mut sp = Spinner::new(Spinners::Dots, "Loading things into memory...".into(), None); + /// let mut sp = Spinner::new(Spinners::Dots, "Loading things into memory...".into()); /// /// sp.stop_with_message("Finished loading things into memory!".into()); /// ``` @@ -205,7 +229,7 @@ impl Spinner { /// ``` /// use spinners::{Spinner, Spinners}; /// - /// let mut sp = Spinner::new(Spinners::Dots, "Loading things into memory...".into(), None); + /// let mut sp = Spinner::new(Spinners::Dots, "Loading things into memory...".into()); /// /// sp.stop_and_persist("✔", "Finished loading things into memory!".into()); /// ``` diff --git a/src/utils/color.rs b/src/utils/color.rs index 0c61042..ea2e22f 100644 --- a/src/utils/color.rs +++ b/src/utils/color.rs @@ -19,7 +19,7 @@ pub fn colorize(input: String, color: Option) -> Paint { Some(Color::Red) => Paint::red(input), Some(Color::Yellow) => Paint::yellow(input), Some(Color::Cyan) => Paint::cyan(input), - Some(Color::White) => Paint::new(input), + Some(Color::White) => Paint::white(input), Some(Color::Magenta) => Paint::magenta(input), Some(Color::Black) => Paint::black(input), None => Paint::new(input), diff --git a/src/utils/spinner_names.rs b/src/utils/spinner_names.rs index a954ca4..4ba6f22 100644 --- a/src/utils/spinner_names.rs +++ b/src/utils/spinner_names.rs @@ -1,6 +1,6 @@ use strum::{Display, EnumIter, EnumString}; -#[derive(Debug, Clone, EnumIter, Display, EnumString)] +#[derive(Debug, Copy, Clone, EnumIter, Display, EnumString)] pub enum SpinnerNames { Dots, Dots2,