Upgrade to clap 3

Author: N3xed

cargo-idf/Cargo.toml

@@ -11,9 +11,10 @@ embuild = { version = "0.27", path = "..", features = ["espidf"] }
 log = "0.4"
 env_logger = "0.8"
 cargo_metadata = "0.14"
-structopt = "0.3"
-clap-cargo = { version = "0.7", features = ["cargo_metadata"] }
+clap = { version = "3", features = ["derive"] }
+clap-cargo = { version = "0.8", features = ["cargo_metadata"] }
 escargot = "0.5"
 serde_json = "1"
 thiserror = "1"
-anyhow = "1"
+anyhow = "1"
+strum = { version = "0.23", features = ["derive"] }

cargo-idf/README.md

@@ -17,9 +17,7 @@ All other options are applied only to the build.
 TODO: Add caution about setting optimization options in sdkconfig.
 
 <details>
-<summary>
-Commands used
-</summary>
+<summary>Commands used</summary>
 
 ```console
 python esp-idf/tools/kconfig_new/prepare_kconfig_files.py 
@@ -43,6 +41,32 @@ python -m menuconfig esp-idf/Kconfig
 </details>
 
 ## `cargo idf flash`
+
+
+<details>
+<summary>Commands used</summary>
+
+```console
+cmake.exe 
+    -D IDF_PATH="..." 
+    -D SERIAL_TOOL="python esp-idf-v4.3.1/components/esptool_py/esptool/esptool.py --chip esp32c3"
+    -D SERIAL_TOOL_ARGS="--before=default_reset --after=hard_reset write_flash @flash_args"
+    -D WORKING_DIRECTORY=<out-dir>/build
+    -P esp-idf-v4.3.1/components/esptool_py/run_serial_tool.cmake
+```
+
+</details>
+
 ## `cargo idf monitor`
 ## `cargo idf erase-flash`
+
+<details>
+<summary>Commands used</summary>
+
+```console
+  COMMAND = cmd.exe /C "cd /D C:\Users\n3xed\.espressif\esp-idf-v4.3.1\components\esptool_py && C:\Users\n3xed\.espressif\tools\cmake\3.20.3\bin\cmake.exe -D IDF_PATH="C:/Users/n3xed/.espressif/esp-idf-v4.3.1" -D SERIAL_TOOL="python C:/Users/n3xed/.espressif/esp-idf-v4.3.1/components/esptool_py/esptool/esptool.py --chip esp32c3" -D SERIAL_TOOL_ARGS="erase_flash" -P run_serial_tool.cmake"
+```
+
+</details>
+
 ## `cargo idf size`

cargo-idf/src/build.rs

@@ -1,13 +1,13 @@
 use std::env;
-use std::ffi::{OsStr, OsString};
+use std::ffi::OsStr;
 use std::io::BufReader;
 use std::path::PathBuf;
 use std::process::{Command, Stdio};
 
 use anyhow::anyhow;
 use cargo_metadata::{Message, Version};
+use clap::Args;
 use embuild::utils::CmdError;
-use structopt::StructOpt;
 
 #[derive(Debug, thiserror::Error)]
 pub enum BuildError {
@@ -27,12 +27,16 @@ pub enum BuildError {
     CargoMsgError(#[source] std::io::Error),
 }
 
-#[derive(Debug, StructOpt)]
+#[derive(Debug, Args)]
+#[clap(help_heading = "BUILD OPTIONS")]
 pub struct BuildOpts {
-    #[structopt(flatten)]
+    #[clap(flatten)]
     manifest: clap_cargo::Manifest,
-    #[structopt(flatten)]
+    #[clap(flatten)]
     features: clap_cargo::Features,
+    /// Build with release profile
+    #[clap(long)]
+    release: bool,
 }
 
 pub struct BuildInfo {
@@ -65,19 +69,22 @@ pub fn run(opts: BuildOpts) -> Result<BuildInfo, BuildError> {
     drop(meta);
 
     // Build the crate
-    let mut cmd = Command::new(env::var_os("CARGO").unwrap_or_else(|| OsString::from("cargo")));
+    let mut cmd = Command::new(env::var_os("CARGO").unwrap_or_else(|| "cargo".into()));
     cmd.args(&["build", "--message-format=json-diagnostic-rendered-ansi"])
         .stdout(Stdio::piped())
         .stderr(Stdio::inherit());
     if let Some(ref manifest) = opts.manifest.manifest_path {
-        cmd.args(&[OsStr::new("--manifest-path"), manifest.as_os_str()]);
+        cmd.args([OsStr::new("--manifest-path"), manifest.as_os_str()]);
     }
     if opts.features.all_features {
         cmd.arg("--all-features");
     }
     if opts.features.no_default_features {
         cmd.arg("--no-default-features");
     }
+    if opts.release {
+        cmd.arg("--release");
+    }
     if !opts.features.features.is_empty() {
         cmd.args(&["--features", &opts.features.features.join(",")]);
     }

cargo-idf/src/flash.rs

@@ -0,0 +1,71 @@
+use std::ffi::OsStr;
+use std::path::PathBuf;
+use std::str::FromStr;
+
+use anyhow::bail;
+use clap::{AppSettings, ArgEnum, Args};
+use strum::{Display, EnumString};
+
+use crate::build;
+
+#[derive(Args)]
+#[clap(global_setting = AppSettings::DisableVersionFlag)]
+pub struct FlashOpts {
+    /// Which bootloader to flash [possible values: esp-idf, none, <file>]
+    ///
+    /// - `esp-idf` will flash the bootloader compiled locally from the esp-idf.
+    /// - `none` prevents flashing a bootloader.
+    /// - `<file>` will flash the user provided binary file if it exists.
+    #[clap(
+        long,
+        default_value_t = Bootloader::EspIdf,
+        parse(try_from_os_str = Bootloader::try_from_os_str),
+        verbatim_doc_comment
+    )]
+    bootloader: Bootloader,
+
+    /// How to flash the binary
+    #[clap(long, arg_enum, default_value_t = Mode::Esptool)]
+    mode: Mode,
+
+    #[clap(flatten)]
+    build_opts: build::BuildOpts,
+}
+
+#[derive(Debug, ArgEnum, Clone, Copy)]
+pub enum Mode {
+    Esptool,
+    Dfu,
+    Uf2,
+}
+
+#[derive(Debug, Clone, EnumString, Display)]
+#[strum(serialize_all = "kebab-case")]
+pub enum Bootloader {
+    EspIdf,
+    None,
+    #[strum(default)]
+    #[strum(to_string = "<file>")]
+    File(PathBuf),
+}
+
+impl Bootloader {
+    pub fn try_from_os_str(arg: &OsStr) -> Result<Bootloader, anyhow::Error> {
+        let val = if let Some(arg) = arg.to_str() {
+            Bootloader::from_str(arg).unwrap()
+        } else {
+            Bootloader::File(arg.into())
+        };
+
+        if let Bootloader::File(ref path) = val {
+            if !path.is_file() {
+                bail!("'{}' is not a file", path.display())
+            }
+        }
+        Ok(val)
+    }
+}
+
+pub fn run(opts: FlashOpts) -> anyhow::Result<()> {
+    Ok(())
+}

cargo-idf/src/main.rs

@@ -1,30 +1,35 @@
+use clap::Subcommand;
 use log::LevelFilter;
-use structopt::clap::AppSettings;
-use structopt::StructOpt;
+use clap::AppSettings;
+use clap::Parser;
 
 mod build;
 mod menuconfig;
+mod flash;
 
-#[derive(StructOpt)]
-#[structopt(global_setting = AppSettings::GlobalVersion)]
-#[structopt(bin_name = "cargo")]
+#[derive(Parser)]
+#[clap(global_setting = AppSettings::PropagateVersion)]
+#[clap(global_setting = AppSettings::DeriveDisplayOrder)]
+#[clap(version)]
+#[clap(bin_name = "cargo")]
 struct Opts {
-    #[structopt(subcommand)]
+    #[clap(subcommand)]
     sub_cmd: CargoSubCommand,
 }
 
-#[derive(StructOpt)]
+#[derive(Subcommand)]
 enum CargoSubCommand {
+    #[clap(subcommand)]
     Idf(CargoIdfOpts),
 }
 
-#[derive(StructOpt)]
+#[derive(Subcommand)]
 enum CargoIdfOpts {
     Menuconfig(menuconfig::MenuconfigOpts),
-    Flash,
-    EraseFlash,
+    Flash(flash::FlashOpts),
     Monitor,
     Size,
+    EraseFlash,
 }
 
 fn main() -> anyhow::Result<()> {
@@ -39,9 +44,10 @@ fn main() -> anyhow::Result<()> {
     .format_timestamp(None)
     .init();
 
-    let CargoSubCommand::Idf(opts) = Opts::from_args().sub_cmd;
+    let CargoSubCommand::Idf(opts) = Opts::parse().sub_cmd;
     match opts {
         CargoIdfOpts::Menuconfig(opts) => menuconfig::run(opts)?,
+        CargoIdfOpts::Flash(opts) => flash::run(opts)?,
         _ => unimplemented!(),
     };
 

cargo-idf/src/menuconfig.rs

@@ -8,7 +8,7 @@ use cargo_metadata::Version;
 use embuild::espidf::{self, EspIdfBuildInfo};
 use embuild::utils::CmdError;
 use embuild::{cmd, path_buf};
-use structopt::StructOpt;
+use clap::{Args, AppSettings};
 
 use crate::build::{self, BuildError, BuildInfo};
 
@@ -30,16 +30,17 @@ pub enum MenuconfigError {
     EspIdfSysTooOld(Version),
 }
 
-#[derive(StructOpt)]
+#[derive(Args)]
+#[clap(global_setting = AppSettings::DeriveDisplayOrder)]
+#[clap(global_setting = AppSettings::DisableVersionFlag)]
 pub struct MenuconfigOpts {
-    #[structopt(flatten)]
-    build_opts: build::BuildOpts,
-    /// Path to the esp-idf build info json file.
+    /// Optional path to the esp-idf build info json file.
     ///
-    /// If this option is not specified cargo-idf will perform a `cargo build` in the
+    /// If this argument is not specified cargo-idf will perform a `cargo build` in the
     /// current directory.
-    #[structopt(long)]
     idf_build_info: Option<PathBuf>,
+    #[clap(flatten)]
+    build_opts: build::BuildOpts,
 }
 
 pub fn run(opts: MenuconfigOpts) -> Result<(), MenuconfigError> {