pub(super) const TOLERANCES: u32 = 3;
const POSITIONS: u8 = 12;
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
pub(super) struct Wheel {
position: u8,
major: bool,
}
impl Wheel {
pub(super) fn parse(name: &str) -> Option<Self> {
let trimmed = name.trim();
if trimmed.is_empty() {
return None;
}
Self::parse_camelot(trimmed).or_else(|| Self::parse_classical(trimmed))
}
fn parse_camelot(name: &str) -> Option<Self> {
let (digits, letter) = name.split_at_checked(name.len().checked_sub(1)?)?;
let major = match letter {
"A" | "a" => false,
"B" | "b" => true,
_ => return None,
};
let position: u8 = digits.trim().parse().ok()?;
(1..=POSITIONS)
.contains(&position)
.then_some(Self { position, major })
}
fn parse_classical(name: &str) -> Option<Self> {
let lower = name.to_ascii_lowercase();
CLASSICAL
.iter()
.find(|(text, _, _)| *text == lower)
.map(|&(_, position, major)| Self { position, major })
}
fn relative(self) -> Self {
Self {
major: !self.major,
..self
}
}
fn stepped(self, step: i8) -> Self {
let zero_based = i16::from(self.position).saturating_sub(1) + i16::from(step);
let wrapped = zero_based.rem_euclid(i16::from(POSITIONS));
let position = u8::try_from(wrapped + 1).unwrap_or(self.position);
Self { position, ..self }
}
}
pub(super) fn harmonic_set(key: Wheel, tolerance: u32) -> Vec<Wheel> {
let mut spots = vec![key];
if tolerance >= 1 {
spots.push(key.relative());
}
if tolerance >= 2 {
spots.push(key.stepped(-1));
spots.push(key.stepped(1));
}
spots
}
pub(super) fn sort_text(name: &str) -> String {
match Wheel::parse(name) {
Some(wheel) => format!(
"{:02}{}",
wheel.position,
if wheel.major { 'B' } else { 'A' }
),
None => format!("~{}", name.to_lowercase()),
}
}
const CLASSICAL: [(&str, u8, bool); 34] = [
("abm", 1, false),
("g#m", 1, false),
("b", 1, true),
("ebm", 2, false),
("d#m", 2, false),
("f#", 2, true),
("gb", 2, true),
("bbm", 3, false),
("a#m", 3, false),
("db", 3, true),
("c#", 3, true),
("fm", 4, false),
("ab", 4, true),
("g#", 4, true),
("cm", 5, false),
("eb", 5, true),
("d#", 5, true),
("gm", 6, false),
("bb", 6, true),
("a#", 6, true),
("dm", 7, false),
("f", 7, true),
("am", 8, false),
("c", 8, true),
("em", 9, false),
("g", 9, true),
("bm", 10, false),
("d", 10, true),
("f#m", 11, false),
("gbm", 11, false),
("a", 11, true),
("dbm", 12, false),
("c#m", 12, false),
("e", 12, true),
];
#[cfg(test)]
mod tests {
use super::*;
fn wheel(name: &str) -> Wheel {
Wheel::parse(name).expect("a key this table places")
}
#[test]
fn both_notations_name_the_same_wheel_spot() {
assert_eq!(wheel("1A"), wheel("Abm"));
assert_eq!(wheel("1B"), wheel("B"));
assert_eq!(wheel("12A"), wheel("Dbm"));
assert_eq!(wheel("12A"), wheel("C#m"));
assert_eq!(wheel("2B"), wheel("Gb"));
assert_eq!(wheel("2B"), wheel("F#"));
}
#[test]
fn a_name_off_the_wheel_is_not_placed() {
assert_eq!(Wheel::parse(""), None);
assert_eq!(Wheel::parse("13A"), None);
assert_eq!(Wheel::parse("0A"), None);
assert_eq!(Wheel::parse("A#dim"), None);
assert_eq!(Wheel::parse("Unknown"), None);
}
#[test]
fn the_tolerances_widen_the_way_a_real_reply_did() {
let key = wheel("1A");
assert_eq!(harmonic_set(key, 0), vec![wheel("1A")]);
assert_eq!(harmonic_set(key, 1), vec![wheel("1A"), wheel("1B")]);
assert_eq!(
harmonic_set(key, 2),
vec![wheel("1A"), wheel("1B"), wheel("12A"), wheel("2A")],
"one below 1A is 12A: the wheel is a circle"
);
}
#[test]
fn the_widest_tolerance_wraps_at_both_ends() {
assert_eq!(
harmonic_set(wheel("12B"), 2),
vec![wheel("12B"), wheel("12A"), wheel("11B"), wheel("1B")]
);
}
#[test]
fn a_tolerance_past_the_last_is_clamped_not_refused() {
assert_eq!(harmonic_set(wheel("5A"), 99), harmonic_set(wheel("5A"), 2));
}
#[test]
fn camelot_keys_sort_by_position_and_not_as_text() {
let mut names = ["10A", "1A", "2B", "12A", "1B", "2A"];
names.sort_by_key(|name| sort_text(name));
assert_eq!(names, ["1A", "1B", "2A", "2B", "10A", "12A"]);
}
#[test]
fn a_key_off_the_wheel_sorts_after_every_key_on_it() {
let mut names = ["zzz", "12B", "", "Unknown", "1A"];
names.sort_by_key(|name| sort_text(name));
assert_eq!(names, ["1A", "12B", "", "Unknown", "zzz"]);
}
#[test]
fn every_classical_name_places_on_the_wheel_it_claims() {
for (name, position, major) in CLASSICAL {
let placed = wheel(name);
assert_eq!(
placed,
Wheel { position, major },
"{name} should be {position}{}",
if major { 'B' } else { 'A' }
);
}
}
#[test]
fn the_two_notations_cover_the_same_twenty_four_spots() {
let mut classical: Vec<Wheel> = CLASSICAL
.iter()
.map(|&(_, position, major)| Wheel { position, major })
.collect();
classical.sort_unstable();
classical.dedup();
assert_eq!(classical.len(), 24, "twelve positions, two rings");
}
}