Fix clippy and rustfmt findings

Rename Pair::from_fixed to shift_from_fixed, since a from_* method taking
self trips wrong_self_convention, and gate the tuning playground's global
state behind the wasm feature, which is all that uses it, so the crate
builds without that feature and without dead-code errors.

Author: float3

crates/recursive_ji_core/src/lib.rs

@@ -22,8 +22,7 @@ const JUST_INTONATION: TuningSystem = TuningSystem::FiveLimit;
 const MAJOR_INTERVALS: &[i32] = &[0, 4, 7];
 const DOMINANT_INTERVALS: &[i32] = &[0, 4, 7, 10];
 
-const TWELVE_TET: AnyTuningSystem =
-    AnyTuningSystem::Fixed(TuningSystem::EQUAL_TEMPERAMENT);
+const TWELVE_TET: AnyTuningSystem = AnyTuningSystem::Fixed(TuningSystem::EQUAL_TEMPERAMENT);
 
 const FIXED_C_JUST: AnyTuningSystem = AnyTuningSystem::Fixed(TuningSystem::FiveLimit);
 

wasm/tuningplayground/src/lib.rs

@@ -7,6 +7,7 @@
 //! keyboard layout, and the name of the last chord engraved -- because the
 //! page has one of each.
 
+#[cfg(feature = "wasm")]
 use std::sync::LazyLock;
 use std::sync::Mutex;
 #[cfg(feature = "wasm")]
@@ -18,12 +19,16 @@ pub mod scale;
 
 use music21_rs::Pitch;
 use music21_rs::chord::Chord;
+#[cfg(any(feature = "wasm", test))]
 use scale::Scale;
 
+#[cfg(feature = "wasm")]
 static CURRENT: LazyLock<Mutex<Scale>> = LazyLock::new(|| Mutex::new(Scale::default_scale()));
+#[cfg(feature = "wasm")]
 static KEYMAP: Mutex<KeyMap> = Mutex::new(KeyMap::Us);
 static CHORD_NAME: Mutex<String> = Mutex::new(String::new());
 
+#[cfg(feature = "wasm")]
 fn current() -> std::sync::MutexGuard<'static, Scale> {
     CURRENT.lock().expect("couldn't lock the scale")
 }
@@ -133,6 +138,7 @@ pub const KEY_ROWS: [&[&str]; 4] = [
     ],
 ];
 
+#[cfg(feature = "wasm")]
 fn to_json<T: serde::Serialize>(value: &T) -> String {
     serde_json::to_string(value).expect("the playground's types serialise")
 }
@@ -361,6 +367,7 @@ pub fn chord_details_core(input: &str) -> Result<String, String> {
     ))
 }
 
+#[cfg(any(feature = "wasm", test))]
 fn tuning_marked_hash_core(keys: &str) -> String {
     let mut keys = keys
         .split(',')

wasm/tuningplayground/src/recursive.rs

@@ -177,7 +177,8 @@ impl Pair {
         global.root_hz * ratio_at(global, nearest_step(global, cents))
     }
 
-    fn from_fixed(&self, root: i64, step: i64) -> f64 {
+    /// How far the recursive tuning moves a note from what the global scale plays for it, in cents.
+    fn shift_from_fixed(&self, root: i64, step: i64) -> f64 {
         cents_of(self.frequency(root, step) / self.fixed_frequency(root, step))
     }
 
@@ -233,7 +234,7 @@ impl Pair {
                 let cells = (0..=columns_drawn)
                     .map(|step| {
                         let frequency = self.frequency(root, step);
-                        let from_fixed = self.from_fixed(root, step);
+                        let from_fixed = self.shift_from_fixed(root, step);
                         largest_shift = largest_shift.max(from_fixed.abs());
                         Cell {
                             step,
@@ -387,8 +388,8 @@ mod tests {
                 );
             }
         }
-        assert!((just.from_fixed(4, 4) + 41.059).abs() < 1e-3);
-        assert!((just.from_fixed(2, 7) - 21.506).abs() < 1e-3);
+        assert!((just.shift_from_fixed(4, 4) + 41.059).abs() < 1e-3);
+        assert!((just.shift_from_fixed(2, 7) - 21.506).abs() < 1e-3);
     }
 
     /// A step of an equal division over a step is the step of their sum, so

wasm/tuningplayground/src/scale.rs

@@ -381,9 +381,7 @@ pub fn realize(id: &str, root_hz: f64) -> Result<Scale, String> {
             root_hz,
         );
     }
-    let tuning: TuningSystem = id
-        .parse()
-        .map_err(|_| format!("no tuning is named {id}"))?;
+    let tuning: TuningSystem = id.parse().map_err(|_| format!("no tuning is named {id}"))?;
     Ok(built_in(tuning, root_hz))
 }