Add ImageFormatType enum, normalize other enums and their trait impls

Author: jessebraham

espflash/src/chip/mod.rs

@@ -151,7 +151,7 @@ impl SpiRegisters {
     }
 }
 
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Display, EnumVariantNames, EnumIter)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Display, EnumIter, EnumVariantNames)]
 pub enum Chip {
     #[strum(serialize = "ESP32")]
     Esp32,
@@ -171,13 +171,15 @@ impl FromStr for Chip {
     type Err = Error;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
+        use Chip::*;
+
         match s.to_lowercase().replace('-', "").as_str() {
-            "esp32" => Ok(Chip::Esp32),
-            "esp32c2" => Ok(Chip::Esp32c2),
-            "esp32c3" => Ok(Chip::Esp32c3),
-            "esp32s2" => Ok(Chip::Esp32s2),
-            "esp32s3" => Ok(Chip::Esp32s3),
-            "esp8266" => Ok(Chip::Esp8266),
+            "esp32" => Ok(Esp32),
+            "esp32c2" => Ok(Esp32c2),
+            "esp32c3" => Ok(Esp32c3),
+            "esp32s2" => Ok(Esp32s2),
+            "esp32s3" => Ok(Esp32s3),
+            "esp8266" => Ok(Esp8266),
             _ => Err(Error::UnrecognizedChipName),
         }
     }

espflash/src/elf.rs

@@ -46,7 +46,7 @@ impl FromStr for FlashMode {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Display, EnumVariantNames)]
+#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, Display, EnumVariantNames)]
 #[repr(u8)]
 pub enum FlashFrequency {
     #[strum(serialize = "12M")]
@@ -79,22 +79,20 @@ impl FromStr for FlashFrequency {
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         use FlashFrequency::*;
 
-        let freq = match s.to_uppercase().as_str() {
-            "12M" => Flash12M,
-            "15M" => Flash15M,
-            "16M" => Flash16M,
-            "20M" => Flash20M,
-            "24M" => Flash24M,
-            "26M" => Flash26M,
-            "30M" => Flash30M,
-            "40M" => Flash40M,
-            "48M" => Flash48M,
-            "60M" => Flash60M,
-            "80M" => Flash80M,
-            _ => return Err(Error::InvalidFlashFrequency(s.to_string())),
-        };
-
-        Ok(freq)
+        match s.to_uppercase().as_str() {
+            "12M" => Ok(Flash12M),
+            "15M" => Ok(Flash15M),
+            "16M" => Ok(Flash16M),
+            "20M" => Ok(Flash20M),
+            "24M" => Ok(Flash24M),
+            "26M" => Ok(Flash26M),
+            "30M" => Ok(Flash30M),
+            "40M" => Ok(Flash40M),
+            "48M" => Ok(Flash48M),
+            "60M" => Ok(Flash60M),
+            "80M" => Ok(Flash80M),
+            _ => Err(Error::InvalidFlashFrequency(s.to_string())),
+        }
     }
 }
 

espflash/src/flasher.rs

@@ -91,21 +91,21 @@ impl FromStr for FlashSize {
     type Err = Error;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let size = match s.to_uppercase().as_str() {
-            "256KB" => FlashSize::Flash256Kb,
-            "512KB" => FlashSize::Flash512Kb,
-            "1MB" => FlashSize::Flash1Mb,
-            "2MB" => FlashSize::Flash2Mb,
-            "4MB" => FlashSize::Flash4Mb,
-            "8MB" => FlashSize::Flash8Mb,
-            "16MB" => FlashSize::Flash16Mb,
-            "32MB" => FlashSize::Flash32Mb,
-            "64MB" => FlashSize::Flash64Mb,
-            "128MB" => FlashSize::Flash128Mb,
-            _ => return Err(Error::InvalidFlashSize(s.to_string())),
-        };
-
-        Ok(size)
+        use FlashSize::*;
+
+        match s.to_uppercase().as_str() {
+            "256KB" => Ok(Flash256Kb),
+            "512KB" => Ok(Flash512Kb),
+            "1MB" => Ok(Flash1Mb),
+            "2MB" => Ok(Flash2Mb),
+            "4MB" => Ok(Flash4Mb),
+            "8MB" => Ok(Flash8Mb),
+            "16MB" => Ok(Flash16Mb),
+            "32MB" => Ok(Flash32Mb),
+            "64MB" => Ok(Flash64Mb),
+            "128MB" => Ok(Flash128Mb),
+            _ => Err(Error::InvalidFlashSize(s.to_string())),
+        }
     }
 }
 

espflash/src/image_format/mod.rs

@@ -18,6 +18,31 @@ mod esp8266;
 const ESP_MAGIC: u8 = 0xE9;
 const WP_PIN_DISABLED: u8 = 0xEE;
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Display, EnumVariantNames)]
+#[strum(serialize_all = "kebab-case")]
+pub enum ImageFormatType {
+    Esp8266,
+    IdfBoot,
+    DirectBoot,
+    McuBoot,
+}
+
+impl FromStr for ImageFormatType {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        use ImageFormatType::*;
+
+        match s.to_lowercase().as_str() {
+            "esp8266" => Ok(Esp8266),
+            "idf-boot" => Ok(IdfBoot),
+            "direct-boot" => Ok(DirectBoot),
+            "mcu-boot" => Ok(McuBoot),
+            _ => Err(Error::UnknownImageFormat(s.to_string())),
+        }
+    }
+}
+
 #[derive(Copy, Clone, Zeroable, Pod, Debug)]
 #[repr(C, packed)]
 struct EspCommonHeader {