From 263b6f699224c3e7dacac667eaa9d39dc51b24dd Mon Sep 17 00:00:00 2001
From: Daniel Mayfield <dan@3geeks.org>
Date: Wed, 3 Sep 2025 18:47:00 -0400
Subject: [PATCH] Fixing format nits

---
 src/main.rs | 38 +++++++++++++++++++-------------------
 1 file changed, 19 insertions(+), 19 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index 27adb59..8490dc7 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -111,7 +111,7 @@ async fn main() -> anyhow::Result<()> {
     if adapter_list.is_empty() {
         eprintln!("No Bluetooth adapters found");
     }
-    let uuidMap = build_map();
+    let uuid_map = build_map();
     let command = std::env::args().nth(1).expect("help");
     let param = std::env::args().nth(2).unwrap_or(String::from("aa:bb:cc:dd:ee:ff"));
     let mut help = false;
@@ -177,36 +177,36 @@ async fn main() -> anyhow::Result<()> {
                     peripheral.discover_services().await?;
                     println!("Discover peripheral {:?} services...", &local_name);
                     for service in peripheral.services() {
-                        let mut characteristicInfo = &HashMap::<Uuid,CharacteristicData>::new();
-                        let serviceName;
-                        let unknownServiceName =  &String::from_str("Unknown Service").unwrap();
-                        if let Some(serviceLookup) = uuidMap.get(&service.uuid) {
-                            serviceName = &serviceLookup.name;
-                            characteristicInfo = &serviceLookup.characteristics;
+                        let mut characteristic_info = &HashMap::<Uuid,CharacteristicData>::new();
+                        let service_name;
+                        let unknown_service_name =  &String::from_str("Unknown Service").unwrap();
+                        if let Some(service_lookup) = uuid_map.get(&service.uuid) {
+                            service_name = &service_lookup.name;
+                            characteristic_info = &service_lookup.characteristics;
                         }
                         else {
-                            serviceName = &unknownServiceName;
+                            service_name = &unknown_service_name;
                         }
                         println!(
                             "Service UUID {}, name {}",
-                            service.uuid, serviceName
+                            service.uuid, service_name
                         );
                         for characteristic in service.characteristics {
-                            let characteristicName;
-                            let characteristicSize;
-                            let unknownCharacteristicName =  &String::from_str("Unknown Characteristic").unwrap();
-                            if let Some(characteristicLookup) = characteristicInfo.get(&characteristic.uuid) {
-                                characteristicName = &characteristicLookup.name;
-                                characteristicSize = characteristicLookup.expected_size;
+                            let characteristic_name;
+                            let characteristic_size;
+                            let unknown_characteristic_name =  &String::from_str("Unknown Characteristic").unwrap();
+                            if let Some(characteristic_lookup) = characteristic_info.get(&characteristic.uuid) {
+                                characteristic_name = &characteristic_lookup.name;
+                                characteristic_size = characteristic_lookup.expected_size;
                             }
                             else {
-                                characteristicName = unknownCharacteristicName;
-                                characteristicSize = 0;
+                                characteristic_name = unknown_characteristic_name;
+                                characteristic_size = 0;
                             }
-                            println!("  Characteristic  {:?} ({:?}) has {:?}", characteristic.uuid,characteristicName,characteristic.properties);
+                            println!("  Characteristic  {:?} ({:?}) has {:?}", characteristic.uuid,characteristic_name,characteristic.properties);
                             if characteristic.properties.contains(CharPropFlags::READ) {
                                 let data = peripheral.read(&characteristic).await?;
-                                println!("    and {:?} bytes of data data when expecting {:?}",data.len(),characteristicSize);
+                                println!("    and {:?} bytes of data data when expecting {:?}",data.len(),characteristic_size);
                                 println!("    raw data: {:?}",data);
 
                             }