use core::time::Duration;
use crate::domain::{Cadence, SpinnerStyle, Theme, Tick};
#[derive(Debug, Clone)]
pub struct Spinner {
style: SpinnerStyle,
label: Option<String>,
cadence: Cadence,
tick: Tick,
theme: Theme,
custom_frames: Option<&'static [&'static str]>,
}
impl Spinner {
#[must_use]
pub fn builder() -> SpinnerBuilder {
SpinnerBuilder::default()
}
#[must_use]
pub const fn style(&self) -> SpinnerStyle {
self.style
}
#[must_use]
pub const fn label(&self) -> Option<&str> {
match &self.label {
Some(s) => Some(s.as_str()),
None => None,
}
}
#[must_use]
pub const fn cadence(&self) -> Cadence {
self.cadence
}
#[must_use]
pub const fn tick(&self) -> Tick {
self.tick
}
#[must_use]
pub const fn theme(&self) -> Theme {
self.theme
}
#[must_use]
pub fn current_frame(&self) -> &'static str {
if let Some(frames) = self.custom_frames {
let len = frames.len();
if len == 0 {
return "";
}
let idx = (self.tick.0 as usize) % len;
frames.get(idx).copied().unwrap_or("")
} else {
self.style.frame_at(self.tick)
}
}
#[must_use]
pub const fn frame_count(&self) -> usize {
if let Some(frames) = self.custom_frames {
frames.len()
} else {
self.style.frame_count()
}
}
#[must_use]
pub fn with_frames(frames: &'static [&'static str]) -> Self {
Self::builder().frames(frames).build()
}
pub fn advance(&mut self, elapsed: Duration) -> u8 {
let elapsed_ms = u64::try_from(elapsed.as_millis()).unwrap_or(u64::MAX);
let cadence_ms = u64::from(self.cadence.millis());
if elapsed_ms < cadence_ms {
return 0;
}
let frames = u8::try_from(elapsed_ms / cadence_ms).unwrap_or(u8::MAX);
for _ in 0..frames {
self.tick = self.tick.next();
}
frames
}
pub fn tick_at(&mut self, total_elapsed: Duration) {
let cadence_ms = u128::from(self.cadence.millis());
let tick_n = u32::try_from(total_elapsed.as_millis() / cadence_ms).unwrap_or(u32::MAX);
self.tick = Tick(tick_n);
}
pub fn set_style(&mut self, style: SpinnerStyle) {
if self.style != style {
self.style = style;
self.tick = Tick::ZERO;
}
}
pub fn set_label(&mut self, label: Option<String>) {
self.label = label;
}
}
#[derive(Debug, Default, Clone)]
pub struct SpinnerBuilder {
style: Option<SpinnerStyle>,
label: Option<String>,
cadence: Option<Cadence>,
theme: Theme,
frames: Option<&'static [&'static str]>,
}
impl SpinnerBuilder {
#[must_use]
pub const fn style(mut self, style: SpinnerStyle) -> Self {
self.style = Some(style);
self
}
#[must_use]
pub fn label(mut self, label: impl Into<String>) -> Self {
self.label = Some(label.into());
self
}
#[must_use]
pub const fn cadence(mut self, cadence: Cadence) -> Self {
self.cadence = Some(cadence);
self
}
#[must_use]
pub const fn theme(mut self, theme: Theme) -> Self {
self.theme = theme;
self
}
#[must_use]
pub fn build(self) -> Spinner {
Spinner {
style: self.style.unwrap_or_default(),
label: self.label,
cadence: self.cadence.unwrap_or_default(),
tick: Tick::ZERO,
theme: self.theme,
custom_frames: self.frames,
}
}
#[must_use]
pub const fn frames(mut self, frames: &'static [&'static str]) -> Self {
self.frames = Some(frames);
self
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn builder_defaults_are_safe() {
let s = Spinner::builder().build();
assert_eq!(s.style(), SpinnerStyle::Dots);
assert_eq!(s.label(), None);
assert_eq!(s.cadence(), Cadence::NORMAL);
assert_eq!(s.tick(), Tick::ZERO);
assert_eq!(s.current_frame(), SpinnerStyle::Dots.frame_at(Tick::ZERO));
}
#[test]
fn advance_below_cadence_is_zero() {
let mut s = Spinner::builder().cadence(Cadence(100)).build();
let n = s.advance(Duration::from_millis(50));
assert_eq!(n, 0);
assert_eq!(s.tick(), Tick::ZERO);
}
#[test]
fn advance_at_one_interval_advances_once() {
let mut s = Spinner::builder().cadence(Cadence(100)).build();
let n = s.advance(Duration::from_millis(100));
assert_eq!(n, 1);
assert_eq!(s.tick(), Tick(1));
}
#[test]
fn advance_by_multiple_intervals() {
let mut s = Spinner::builder().cadence(Cadence(100)).build();
let n = s.advance(Duration::from_millis(450));
assert_eq!(n, 4); assert_eq!(s.tick(), Tick(4));
}
#[test]
fn advance_saturates_at_u8_max() {
let mut s = Spinner::builder().cadence(Cadence(1)).build();
let n = s.advance(Duration::from_secs(60)); assert_eq!(n, u8::MAX);
}
#[test]
fn tick_at_drives_from_total_elapsed() {
let mut s = Spinner::builder().cadence(Cadence(50)).build();
s.tick_at(Duration::from_millis(250));
assert_eq!(s.tick(), Tick(5));
}
#[test]
fn tick_at_is_independent_of_loop_rate() {
let mut a = Spinner::builder().cadence(Cadence(60)).build();
let mut b = Spinner::builder().cadence(Cadence(60)).build();
a.tick_at(Duration::from_millis(180));
for _ in 0..5 {
b.tick_at(Duration::from_millis(180));
}
assert_eq!(a.tick(), b.tick());
}
#[test]
fn set_style_resets_tick_when_changed() {
let mut s = Spinner::builder().style(SpinnerStyle::Dots).build();
s.advance(Duration::from_millis(80 * 5));
assert_eq!(s.tick(), Tick(5));
s.set_style(SpinnerStyle::Line);
assert_eq!(s.tick(), Tick::ZERO);
assert_eq!(s.style(), SpinnerStyle::Line);
}
#[test]
fn set_style_same_value_keeps_tick() {
let mut s = Spinner::builder().style(SpinnerStyle::Dots).build();
s.advance(Duration::from_millis(80 * 3));
let before = s.tick();
s.set_style(SpinnerStyle::Dots); assert_eq!(s.tick(), before);
}
}