use blubat_core::Device;
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum Sort {
#[default]
Level,
Name,
LastSeen,
}
impl Sort {
pub fn next(self) -> Self {
match self {
Sort::Level => Sort::Name,
Sort::Name => Sort::LastSeen,
Sort::LastSeen => Sort::Level,
}
}
pub fn label(self) -> &'static str {
match self {
Sort::Level => "level",
Sort::Name => "name",
Sort::LastSeen => "last seen",
}
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct Filter {
pub query: String,
}
impl Filter {
pub fn narrows(&self) -> bool {
!self.query.trim().is_empty()
}
fn keeps(&self, device: &Device) -> bool {
!self.narrows() || device.matches(&self.query)
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct View {
pub sort: Sort,
pub filter: Filter,
pub hidden: Vec<String>,
pub show_hidden: bool,
}
impl View {
pub fn hiding(hidden: &[String]) -> Self {
Self {
hidden: hidden.to_vec(),
..Self::default()
}
}
fn shows(&self, device: &Device) -> bool {
self.filter.keeps(device) && (self.show_hidden || !self.hides(device))
}
fn hides(&self, device: &Device) -> bool {
self.hidden.iter().any(|pattern| device.matches(pattern))
}
pub fn toggle_hidden(&mut self, device: &Device) {
let hidden = self.hides(device);
self.hidden.retain(|pattern| !device.matches(pattern));
if !hidden {
self.hidden.push(device.address.to_string());
}
}
}
#[derive(Debug, PartialEq, Eq)]
pub struct Rows<'a> {
pub active: Vec<&'a Device>,
pub inactive: Vec<&'a Device>,
}
impl<'a> Rows<'a> {
pub fn of(devices: &'a [Device], view: &View) -> Self {
let (active, inactive) = devices
.iter()
.filter(|device| view.shows(device))
.partition::<Vec<_>, _>(|device| device.connected);
Self {
active: sorted(active, view.sort),
inactive: sorted(inactive, view.sort),
}
}
pub fn all(&self) -> impl Iterator<Item = &'a Device> {
self.active.iter().chain(&self.inactive).copied()
}
pub fn len(&self) -> usize {
self.active.len() + self.inactive.len()
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
pub fn get(&self, index: usize) -> Option<&'a Device> {
self.all().nth(index)
}
}
fn sorted(mut devices: Vec<&Device>, sort: Sort) -> Vec<&Device> {
match sort {
Sort::Level => devices.sort_by_key(|device| {
let level = device.levels.lowest();
(level.is_none(), level)
}),
Sort::Name => devices.sort_by_key(|device| device.name.to_lowercase()),
Sort::LastSeen => devices.sort_by_key(|device| std::cmp::Reverse(device.read_at)),
}
devices
}
#[cfg(test)]
mod tests {
use blubat_core::{Address, ChargeState, Levels, Source, Timestamp};
use super::*;
const READ_AT: i64 = 1_785_643_199;
fn device(name: &str, address: &str, level: Option<u8>) -> Device {
Device {
address: Address::parse(address).expect("valid address"),
name: name.to_string(),
kind: None,
transport: None,
levels: Levels {
main: level,
..Levels::default()
},
charge: ChargeState::Discharging,
source: Source::IoKit,
connected: true,
read_at: Timestamp::from_unix(READ_AT),
}
}
fn offline(name: &str, address: &str, level: Option<u8>) -> Device {
Device {
connected: false,
..device(name, address, level)
}
}
fn devices() -> Vec<Device> {
vec![
device("Magic Trackpad", "30-82-16-f2-24-90", Some(85)),
device("MX Keys M Mac", "de-df-38-f0-46-9b", Some(9)),
device("Soundcore Liberty", "d0-03-4b-0b-e6-4e", None),
offline("AirPods Pro", "74-15-f5-02-8e-38", Some(4)),
]
}
fn names<'a>(rows: impl Iterator<Item = &'a Device>) -> Vec<String> {
rows.map(|device| device.name.clone()).collect()
}
fn shown(devices: &[Device], view: &View) -> Vec<String> {
Rows::of(devices, view)
.all()
.map(|device| device.name.clone())
.collect()
}
fn filtered(query: &str) -> View {
View {
filter: Filter {
query: query.to_string(),
},
..View::default()
}
}
#[test]
fn connected_devices_come_before_disconnected_ones() {
let devices = devices();
let rows = Rows::of(&devices, &View::default());
assert_eq!(rows.active.len(), 3);
assert_eq!(rows.inactive.len(), 1);
assert_eq!(rows.len(), 4);
assert_eq!(
rows.get(3).map(|device| device.name.as_str()),
Some("AirPods Pro"),
"the inactive section is selected through last"
);
assert_eq!(rows.get(4), None);
}
#[test]
fn each_order_lists_the_devices_its_own_way() {
let devices = devices();
let by = |sort| {
shown(
&devices,
&View {
sort,
..View::default()
},
)
};
assert_eq!(
by(Sort::Level),
[
"MX Keys M Mac",
"Magic Trackpad",
"Soundcore Liberty",
"AirPods Pro"
],
"emptiest first, unread last, each section on its own"
);
assert_eq!(
by(Sort::Name),
[
"Magic Trackpad",
"MX Keys M Mac",
"Soundcore Liberty",
"AirPods Pro"
]
);
}
#[test]
fn the_freshest_reading_leads_the_last_seen_order() {
let devices = vec![
Device {
read_at: Timestamp::from_unix(READ_AT - 300),
..device("Stale", "aa-aa-aa-aa-aa-aa", Some(50))
},
device("Fresh", "bb-bb-bb-bb-bb-bb", Some(50)),
];
assert_eq!(
shown(
&devices,
&View {
sort: Sort::LastSeen,
..View::default()
}
),
["Fresh", "Stale"]
);
}
#[test]
fn an_order_that_cannot_separate_two_devices_leaves_them_as_they_came() {
let devices = vec![
device("Alpha", "aa-aa-aa-aa-aa-aa", Some(50)),
device("Beta", "bb-bb-bb-bb-bb-bb", Some(50)),
];
for sort in [Sort::Level, Sort::Name, Sort::LastSeen] {
assert_eq!(
shown(
&devices,
&View {
sort,
..View::default()
}
),
["Alpha", "Beta"],
"{sort:?}"
);
}
}
#[test]
fn the_filter_matches_a_name_or_an_address() {
let devices = devices();
assert_eq!(shown(&devices, &filtered("keys")), ["MX Keys M Mac"]);
assert_eq!(shown(&devices, &filtered("KEYS")), ["MX Keys M Mac"]);
assert_eq!(shown(&devices, &filtered("74-15")), ["AirPods Pro"]);
assert_eq!(shown(&devices, &filtered("74:15")), ["AirPods Pro"]);
assert!(shown(&devices, &filtered("nothing here")).is_empty());
}
#[test]
fn a_filter_of_whitespace_narrows_nothing() {
let devices = devices();
assert!(!filtered(" ").filter.narrows());
assert_eq!(shown(&devices, &filtered(" ")).len(), 4);
assert_eq!(shown(&devices, &View::default()).len(), 4);
}
#[test]
fn a_hidden_device_is_gone_until_hidden_devices_are_shown() {
let devices = devices();
let mut view = View::default();
view.toggle_hidden(&devices[0]);
assert_eq!(shown(&devices, &view).len(), 3);
assert!(!shown(&devices, &view).contains(&"Magic Trackpad".to_string()));
view.show_hidden = true;
assert_eq!(shown(&devices, &view).len(), 4);
view.toggle_hidden(&devices[0]);
view.show_hidden = false;
assert_eq!(shown(&devices, &view).len(), 4, "and hiding is reversible");
}
#[test]
fn a_new_hide_is_written_as_the_address_that_cannot_be_renamed() {
let devices = devices();
let mut view = View::default();
view.toggle_hidden(&devices[0]);
assert_eq!(view.hidden, ["30-82-16-f2-24-90"]);
}
#[test]
fn the_config_files_matches_are_the_devices_the_dashboard_opens_without() {
let devices = devices();
let view = View::hiding(&["MX Keys".to_string()]);
assert_eq!(
shown(&devices, &view),
["Magic Trackpad", "Soundcore Liberty", "AirPods Pro"],
"a name a person wrote hides as readily as an address"
);
}
#[test]
fn showing_a_device_again_drops_every_match_that_was_hiding_it() {
let devices = devices();
let mut view = View::hiding(&["MX Keys".to_string(), "de-df-38".to_string()]);
view.toggle_hidden(&devices[1]);
assert!(view.hidden.is_empty(), "one press, however it was hidden");
assert_eq!(shown(&devices, &view).len(), 4);
}
#[test]
fn hiding_appends_rather_than_reordering_what_the_file_already_held() {
let devices = devices();
let mut view = View::hiding(&["MX Keys".to_string()]);
view.toggle_hidden(&devices[0]);
assert_eq!(view.hidden, ["MX Keys", "30-82-16-f2-24-90"]);
}
#[test]
fn the_orders_cycle_and_name_themselves() {
assert_eq!(Sort::Level.next(), Sort::Name);
assert_eq!(Sort::Name.next(), Sort::LastSeen);
assert_eq!(Sort::LastSeen.next(), Sort::Level);
assert_eq!(Sort::default(), Sort::Level);
for sort in [Sort::Level, Sort::Name, Sort::LastSeen] {
assert!(!sort.label().is_empty());
}
}
#[test]
fn nothing_read_yet_is_no_rows_rather_than_an_absence() {
let rows = Rows::of(&[], &View::default());
assert!(rows.is_empty());
assert_eq!(names(rows.all()), Vec::<String>::new());
}
}