Remove get_ prefixes from various functions (#824)

* Rename `get_flash_image` function to `flash_image`

* Rename `get_serial_port_info` function to `serial_port_info`

* Remove `get_` prefix from some functions in `Symbol` struct

* Remove `get_` prefix from some functions in `flasher` module

* Remove all remaining `get_` prefixes

* Update `CHANGELOG.md`

Author: jessebraham

CHANGELOG.md

@@ -33,6 +33,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `IdfBootloaderFormat` has had its constructor's parameters reduced/simplified (#798)
 - Update flash size when creating the app partition (#797)
 - `--non-interactive` may now react to key events (user input, Ctrl-C, Ctrl-R) if possible (#819)
+- Removed `get_` prefix from any functions which previously had it (#824)
 
 ### Fixed
 

espflash/src/cli/config.rs

@@ -102,27 +102,9 @@ pub struct Config {
 }
 
 impl Config {
-    /// Gets the path to the configuration file.
-    pub fn get_config_path() -> Result<PathBuf, Error> {
-        let local_config = std::env::current_dir()?.join("espflash.toml");
-        if local_config.exists() {
-            return Ok(local_config);
-        }
-        if let Some(parent_folder) = std::env::current_dir()?.parent() {
-            let workspace_config = parent_folder.join("espflash.toml");
-            if workspace_config.exists() {
-                return Ok(workspace_config);
-            }
-        }
-
-        let project_dirs = ProjectDirs::from("rs", "esp", "espflash").unwrap();
-        let global_config = project_dirs.config_dir().join("espflash.toml");
-        Ok(global_config)
-    }
-
     /// Load configuration from the configuration file
     pub fn load() -> Result<Self> {
-        let file = Self::get_config_path()?;
+        let file = Self::config_path()?;
 
         let mut config = if let Ok(data) = read_to_string(&file) {
             toml::from_str(&data).into_diagnostic()?
@@ -163,6 +145,23 @@ impl Config {
             .into_diagnostic()
             .wrap_err_with(|| format!("Failed to write config to {}", self.save_path.display()))
     }
+
+    fn config_path() -> Result<PathBuf, Error> {
+        let local_config = std::env::current_dir()?.join("espflash.toml");
+        if local_config.exists() {
+            return Ok(local_config);
+        }
+        if let Some(parent_folder) = std::env::current_dir()?.parent() {
+            let workspace_config = parent_folder.join("espflash.toml");
+            if workspace_config.exists() {
+                return Ok(workspace_config);
+            }
+        }
+
+        let project_dirs = ProjectDirs::from("rs", "esp", "espflash").unwrap();
+        let global_config = project_dirs.config_dir().join("espflash.toml");
+        Ok(global_config)
+    }
 }
 
 #[cfg(test)]

espflash/src/cli/mod.rs

@@ -31,7 +31,6 @@ use serialport::{FlowControl, SerialPortInfo, SerialPortType, UsbPortInfo};
 use self::{
     config::Config,
     monitor::{monitor, LogFormat},
-    serial::get_serial_port_info,
 };
 use crate::{
     connection::reset::{ResetAfterOperation, ResetBeforeOperation},
@@ -369,7 +368,7 @@ pub fn connect(
         );
     }
 
-    let port_info = get_serial_port_info(args, config)?;
+    let port_info = serial::serial_port_info(args, config)?;
 
     // Attempt to open the serial port and set its initial baud rate.
     info!("Serial port: '{}'", port_info.port_name);
@@ -417,7 +416,7 @@ pub fn board_info(args: &ConnectArgs, config: &Config) -> Result<()> {
     print_board_info(&mut flasher)?;
 
     if flasher.chip() != Chip::Esp32 {
-        let security_info = flasher.get_security_info()?;
+        let security_info = flasher.security_info()?;
         println!("{security_info}");
     } else {
         println!("Security features: None");
@@ -614,7 +613,7 @@ pub fn save_elf_as_image(
         // For simplicity, the revision None is used
         let image = chip
             .into_target()
-            .get_flash_image(elf, flash_data.clone(), None, xtal_freq)?;
+            .flash_image(elf, flash_data.clone(), None, xtal_freq)?;
 
         display_image_size(image.app_size(), image.part_size());
 
@@ -648,7 +647,7 @@ pub fn save_elf_as_image(
     } else {
         let image = chip
             .into_target()
-            .get_flash_image(elf, flash_data, None, xtal_freq)?;
+            .flash_image(elf, flash_data, None, xtal_freq)?;
 
         display_image_size(image.app_size(), image.part_size());
 

espflash/src/cli/monitor/mod.rs

@@ -201,7 +201,7 @@ fn deduce_log_format(elf: Option<&[u8]>) -> LogFormat {
     };
 
     let Some(format_symbol) =
-        symbols.get_symbol_data(Some(".espressif.metadata"), b"espflash.LOG_FORMAT")
+        symbols.symbol_data(Some(".espressif.metadata"), b"espflash.LOG_FORMAT")
     else {
         return LogFormat::Serial;
     };

espflash/src/cli/monitor/parser/mod.rs

@@ -32,8 +32,8 @@ fn resolve_addresses(
         // successfully into an integer.
         let addr = u64::from_str_radix(&matched[2..], 16).unwrap();
 
-        let name = symbols.get_name(addr);
-        let location = symbols.get_location(addr);
+        let name = symbols.name(addr);
+        let location = symbols.location(addr);
 
         if let Some(name) = name {
             let output = if line.trim() == format!("0x{:x}", addr) {

espflash/src/cli/monitor/symbols.rs

@@ -34,7 +34,7 @@ impl<'sym> Symbols<'sym> {
 
     /// Returns the name of the function at the given address, if one can be
     /// found.
-    pub fn get_name(&self, addr: u64) -> Option<String> {
+    pub fn name(&self, addr: u64) -> Option<String> {
         // No need to try an address not contained in any segment:
         if !self.object.segments().any(|segment| {
             (segment.address()..(segment.address() + segment.size())).contains(&addr)
@@ -85,7 +85,7 @@ impl<'sym> Symbols<'sym> {
 
     /// Returns the file name and line number of the function at the given
     /// address, if one can be.
-    pub fn get_location(&self, addr: u64) -> Option<(String, u32)> {
+    pub fn location(&self, addr: u64) -> Option<(String, u32)> {
         // Find the location which `addr` is in. If we can dedetermine a file name and
         // line number for this function we will return them both in a tuple.
         self.ctx.find_location(addr).ok()?.map(|location| {
@@ -99,7 +99,7 @@ impl<'sym> Symbols<'sym> {
         })?
     }
 
-    pub(crate) fn get_symbol_data(
+    pub(crate) fn symbol_data(
         &self,
         section_name: Option<&str>,
         name_bytes: &[u8],

espflash/src/cli/serial.rs

@@ -14,10 +14,7 @@ use crate::{
 
 /// Return the information of a serial port taking into account the different
 /// ways of choosing a port.
-pub fn get_serial_port_info(
-    matches: &ConnectArgs,
-    config: &Config,
-) -> Result<SerialPortInfo, Error> {
+pub fn serial_port_info(matches: &ConnectArgs, config: &Config) -> Result<SerialPortInfo, Error> {
     // A serial port should be specified either as a command-line argument or in a
     // configuration file. In the case that both have been provided the command-line
     // argument takes precedence.

espflash/src/connection/mod.rs

@@ -383,7 +383,7 @@ impl Connection {
     }
 
     /// Get the current baud rate of the serial port
-    pub fn get_baud(&self) -> Result<u32, Error> {
+    pub fn baud(&self) -> Result<u32, Error> {
         Ok(self.serial.baud_rate()?)
     }
 

espflash/src/flasher/mod.rs

@@ -86,7 +86,7 @@ impl SecurityInfo {
         ])
     }
 
-    fn get_security_flag_status(&self, flag_name: &str) -> bool {
+    fn security_flag_status(&self, flag_name: &str) -> bool {
         if let Some(&flag) = Self::security_flag_map().get(flag_name) {
             (self.flags & flag) != 0
         } else {
@@ -162,9 +162,9 @@ impl fmt::Display for SecurityInfo {
         }
 
         // Secure Boot
-        if self.get_security_flag_status("SECURE_BOOT_EN") {
+        if self.security_flag_status("SECURE_BOOT_EN") {
             writeln!(f, "Secure Boot: Enabled")?;
-            if self.get_security_flag_status("SECURE_BOOT_AGGRESSIVE_REVOKE") {
+            if self.security_flag_status("SECURE_BOOT_AGGRESSIVE_REVOKE") {
                 writeln!(f, "Secure Boot Aggressive key revocation: Enabled")?;
             }
 
@@ -175,7 +175,7 @@ impl fmt::Display for SecurityInfo {
             ]
             .iter()
             .enumerate()
-            .filter(|(_, &key)| self.get_security_flag_status(key))
+            .filter(|(_, &key)| self.security_flag_status(key))
             .map(|(i, _)| format!("Secure Boot Key{} is Revoked", i))
             .collect();
 
@@ -201,22 +201,22 @@ impl fmt::Display for SecurityInfo {
         writeln!(f, "{}: 0x{:x}", crypt_cnt_str, self.flash_crypt_cnt)?;
 
         // Cache Disabling
-        if self.get_security_flag_status("DIS_DOWNLOAD_DCACHE") {
+        if self.security_flag_status("DIS_DOWNLOAD_DCACHE") {
             writeln!(f, "Dcache in UART download mode: Disabled")?;
         }
-        if self.get_security_flag_status("DIS_DOWNLOAD_ICACHE") {
+        if self.security_flag_status("DIS_DOWNLOAD_ICACHE") {
             writeln!(f, "Icache in UART download mode: Disabled")?;
         }
 
         // JTAG Status
-        if self.get_security_flag_status("HARD_DIS_JTAG") {
+        if self.security_flag_status("HARD_DIS_JTAG") {
             writeln!(f, "JTAG: Permanently Disabled")?;
-        } else if self.get_security_flag_status("SOFT_DIS_JTAG") {
+        } else if self.security_flag_status("SOFT_DIS_JTAG") {
             writeln!(f, "JTAG: Software Access Disabled")?;
         }
 
         // USB Access
-        if self.get_security_flag_status("DIS_USB") {
+        if self.security_flag_status("DIS_USB") {
             writeln!(f, "USB Access: Disabled")?;
         }
 
@@ -1057,7 +1057,7 @@ impl Flasher {
         let image =
             self.chip
                 .into_target()
-                .get_flash_image(elf, flash_data, chip_revision, xtal_freq)?;
+                .flash_image(elf, flash_data, chip_revision, xtal_freq)?;
 
         // When the `cli` feature is enabled, display the image size information.
         #[cfg(feature = "cli")]
@@ -1124,15 +1124,15 @@ impl Flasher {
     }
 
     /// Get security info
-    pub fn get_security_info(&mut self) -> Result<SecurityInfo, Error> {
-        get_security_info(&mut self.connection, self.use_stub)
+    pub fn security_info(&mut self) -> Result<SecurityInfo, Error> {
+        security_info(&mut self.connection, self.use_stub)
     }
 
     pub fn change_baud(&mut self, speed: u32) -> Result<(), Error> {
         debug!("Change baud to: {}", speed);
 
         let prior_baud = match self.use_stub {
-            true => self.connection.get_baud()?,
+            true => self.connection.baud()?,
             false => 0,
         };
 
@@ -1350,7 +1350,7 @@ impl Flasher {
 }
 
 #[cfg(feature = "serialport")]
-fn get_security_info(connection: &mut Connection, use_stub: bool) -> Result<SecurityInfo, Error> {
+fn security_info(connection: &mut Connection, use_stub: bool) -> Result<SecurityInfo, Error> {
     connection.with_timeout(CommandType::GetSecurityInfo.timeout(), |connection| {
         let response = connection.command(Command::GetSecurityInfo)?;
         // Extract raw bytes and convert them into `SecurityInfo`
@@ -1369,7 +1369,7 @@ fn get_security_info(connection: &mut Connection, use_stub: bool) -> Result<Secu
 
 #[cfg(feature = "serialport")]
 fn detect_chip(connection: &mut Connection, use_stub: bool) -> Result<Chip, Error> {
-    match get_security_info(connection, use_stub) {
+    match security_info(connection, use_stub) {
         Ok(info) if info.chip_id.is_some() => {
             let chip_id = info.chip_id.unwrap() as u16;
             let chip = Chip::try_from(chip_id)?;

espflash/src/image_format/esp_idf.rs

@@ -206,7 +206,7 @@ impl<'a> IdfBootloaderFormat<'a> {
 
         for segment in flash_segments {
             loop {
-                let pad_len = get_segment_padding(data.len(), &segment);
+                let pad_len = segment_padding(data.len(), &segment);
                 if pad_len > 0 {
                     if pad_len > SEG_HEADER_LEN {
                         if let Some(ram_segment) = ram_segments.first_mut() {
@@ -399,7 +399,7 @@ fn default_partition_table(params: &Esp32Params, flash_size: Option<u32>) -> Par
 ///
 /// (this is because the segment's vaddr may not be IROM_ALIGNed, more likely is
 /// aligned IROM_ALIGN+0x18 to account for the binary file header)
-fn get_segment_padding(offset: usize, segment: &Segment<'_>) -> u32 {
+fn segment_padding(offset: usize, segment: &Segment<'_>) -> u32 {
     let align_past = (segment.addr - SEG_HEADER_LEN) % IROM_ALIGN;
     let pad_len = ((IROM_ALIGN - ((offset as u32) % IROM_ALIGN)) + align_past) % IROM_ALIGN;