Update clap requirement from 3.1.0 to 4.0.8 (#137)

dependabot[bot] · flavio · web-flow · commit cbb1e3f32c34 · 2022-10-05T08:12:07.000+01:00
* Update clap requirement from 3.1.0 to 4.0.8 Updates the requirements on [clap](https://github.com/clap-rs/clap) to permit the latest version. - [Release notes](https://github.com/clap-rs/clap/releases) - [Changelog](https://github.com/clap-rs/clap/blob/master/CHANGELOG.md) - [Commits](clap-rs/clap@clap_complete-v3.1.0...v4.0.8) --- updated-dependencies: - dependency-name: clap dependency-type: direct:production ... Signed-off-by: dependabot[bot] <support@github.com> * chore: upgrade to latest version of clap Fix the code to address the API changes of clap v4 Signed-off-by: Flavio Castelli <fcastelli@suse.com> Signed-off-by: dependabot[bot] <support@github.com> Signed-off-by: Flavio Castelli <fcastelli@suse.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Co-authored-by: Flavio Castelli <fcastelli@suse.com>
diff --git a/Cargo.toml b/Cargo.toml
@@ -54,7 +54,7 @@ ed25519-dalek-fiat = "0.1.0"
 anyhow = "1.0.54"
 assert-json-diff = "2.0.2"
 chrono = "0.4.20"
-clap = { version = "3.1.0", features = ["derive"] }
+clap = { version = "4.0.8", features = ["derive"] }
 openssl = "0.10.38"
 rstest = "0.15.0"
 tempfile = "3.3.0"
diff --git a/examples/cosign/verify/main.rs b/examples/cosign/verify/main.rs
@@ -76,14 +76,7 @@ struct Cli {
     cert_url: Option<String>,
 
     /// Annotations that have to be satisfied
-    #[clap(
-        short,
-        long,
-        parse(from_str),
-        takes_value(true),
-        required(false),
-        multiple_occurrences(true)
-    )]
+    #[clap(short, long, required(false))]
     annotations: Vec<String>,
 
     /// Enable verbose mode
diff --git a/examples/rekor/create_log_entry/main.rs b/examples/rekor/create_log_entry/main.rs
@@ -70,27 +70,27 @@ async fn main() {
     let matches = Command::new("cmd")
     .arg(Arg::new("hash")
              .long("hash")
-             .takes_value(true)
+             .value_name("HASH")
              .help("hash of the artifact"))
     .arg(Arg::new("url")
              .long("url")
-             .takes_value(true)
+             .value_name("URL")
              .help("url containing the contents of the artifact (raw github url)"))
     .arg(Arg::new("public_key")
              .long("public_key")
-             .takes_value(true)
+             .value_name("PUBLIC_KEY")
              .help("base64 encoded public_key. Look at https://raw.githubusercontent.com/jyotsna-penumaka/rekor-rs/rekor-functionality/test_data/create_log_entry.md for more details on generating keys."))
     .arg(Arg::new("key_format")
              .long("key_format")
-             .takes_value(true)
+             .value_name("KEY_FORMAT")
              .help("Accepted formats are : pgp / x509 / minsign / ssh / tuf"))  
     .arg(Arg::new("signature")
              .long("signature")
-             .takes_value(true)
+             .value_name("SIGNATURE")
              .help("base64 encoded signature of the artifact. Look at https://raw.githubusercontent.com/jyotsna-penumaka/rekor-rs/rekor-functionality/test_data/create_log_entry.md for more details on generating keys."))
     .arg(Arg::new("api_version")
              .long("api_version")
-             .takes_value(true)
+             .value_name("API_VERSION")
              .help("Rekor-rs open api version"));
 
     let flags = matches.get_matches();
@@ -107,33 +107,39 @@ async fn main() {
 
     let hash = Hash::new(
         AlgorithmKind::sha256,
-        flags.value_of("hash").unwrap_or(HASH).to_string(),
+        flags
+            .get_one::<String>("hash")
+            .unwrap_or(&HASH.to_string())
+            .to_owned(),
     );
     let data = Data::new(
         hash,
-        Url::parse(flags.value_of("url").unwrap_or(URL)).unwrap(),
+        Url::parse(flags.get_one::<String>("url").unwrap_or(&URL.to_string())).unwrap(),
     );
     let public_key = PublicKey::new(
         flags
-            .value_of("public_key")
-            .unwrap_or(PUBLIC_KEY)
-            .to_string(),
+            .get_one::<String>("public_key")
+            .unwrap_or(&PUBLIC_KEY.to_string())
+            .to_owned(),
     );
     let signature = Signature::new(
         flags
-            .value_of("key_format")
-            .unwrap_or(KEY_FORMAT)
-            .to_string(),
-        flags.value_of("signature").unwrap_or(SIGNATURE).to_string(),
+            .get_one::<String>("key_format")
+            .unwrap_or(&KEY_FORMAT.to_string())
+            .to_owned(),
+        flags
+            .get_one("signature")
+            .unwrap_or(&SIGNATURE.to_string())
+            .to_owned(),
         public_key,
     );
     let spec = Spec::new(signature, data);
     let proposed_entry = ProposedEntry::Hashedrekord {
         api_version: flags
-            .value_of("api_version")
-            .unwrap_or(API_VERSION)
-            .to_string(),
-        spec: spec,
+            .get_one::<String>("api_version")
+            .unwrap_or(&API_VERSION.to_string())
+            .to_owned(),
+        spec,
     };
 
     let log_entry = entries_api::create_log_entry(&configuration, proposed_entry).await;
diff --git a/examples/rekor/get_log_entry_by_index/main.rs b/examples/rekor/get_log_entry_by_index/main.rs
@@ -31,15 +31,20 @@ async fn main() {
     let matches = Command::new("cmd").arg(
         Arg::new("log_index")
             .long("log_index")
-            .takes_value(true)
+            .value_name("LOG_INDEX")
             .help("log_index of the artifact"),
     );
 
     // The following default value will be used if the user does not input values using cli flags
     const LOG_INDEX: &str = "1";
 
     let flags = matches.get_matches();
-    let index = i32::from_str(flags.value_of("log_index").unwrap_or(LOG_INDEX)).unwrap();
+    let index = i32::from_str(
+        flags
+            .get_one::<String>("log_index")
+            .unwrap_or(&LOG_INDEX.to_string()),
+    )
+    .unwrap();
 
     let configuration = Configuration::default();
 
diff --git a/examples/rekor/get_log_entry_by_uuid/main.rs b/examples/rekor/get_log_entry_by_uuid/main.rs
@@ -30,15 +30,18 @@ async fn main() {
     let matches = Command::new("cmd").arg(
         Arg::new("uuid")
             .long("uuid")
-            .takes_value(true)
+            .value_name("UUID")
             .help("uuid of the artifact"),
     );
 
     // The following default value will be used if the user does not input values using cli flags
     const UUID: &str = "073970a07c978b7a9ff15b69fe15d87dfb58fd5756086e3d1fb671c2d0bd95c0";
 
     let flags = matches.get_matches();
-    let uuid = flags.value_of("uuid").unwrap_or(UUID).to_string();
+    let uuid = flags
+        .get_one::<String>("uuid")
+        .unwrap_or(&UUID.to_string())
+        .to_owned();
     let configuration = Configuration::default();
     let message: LogEntry = entries_api::get_log_entry_by_uuid(&configuration, &uuid)
         .await
diff --git a/examples/rekor/get_log_proof/main.rs b/examples/rekor/get_log_proof/main.rs
@@ -33,15 +33,15 @@ async fn main() {
     let matches = Command::new("cmd")
     .arg(Arg::new("last_size")
              .long("last_size")
-             .takes_value(true)
+             .value_name("LAST_SIZE")
              .help("The size of the tree that you wish to prove consistency to"))
     .arg(Arg::new("first_size")
              .long("first_size")
-             .takes_value(true)
+             .value_name("FIRST_SIZE")
              .help("The size of the tree that you wish to prove consistency from (1 means the beginning of the log). Defaults to 1. To use the default value, do not input any value"))
     .arg(Arg::new("tree_id")
              .long("tree_id")
-             .takes_value(true)
+             .value_name("TREE_ID")
              .help("The tree ID of the tree that you wish to prove consistency for. To use the default value, do not input any value."));
 
     let configuration = Configuration::default();
@@ -52,9 +52,14 @@ async fn main() {
 
     let log_proof: ConsistencyProof = tlog_api::get_log_proof(
         &configuration,
-        i32::from_str(flags.value_of("last_size").unwrap_or(LAST_SIZE)).unwrap(),
-        flags.value_of("first_size"),
-        flags.value_of("tree_id"),
+        i32::from_str(
+            flags
+                .get_one::<String>("last_size")
+                .unwrap_or(&LAST_SIZE.to_string()),
+        )
+        .unwrap(),
+        flags.get_one::<String>("first_size").map(|s| s.as_str()),
+        flags.get_one::<String>("tree_id").map(|s| s.as_str()),
     )
     .await
     .unwrap();
diff --git a/examples/rekor/get_public_key/main.rs b/examples/rekor/get_public_key/main.rs
@@ -28,11 +28,15 @@ async fn main() {
     let matches = Command::new("cmd")
     .arg(Arg::new("tree_id")
              .long("tree_id")
-             .takes_value(true)
+             .value_name("TREE_ID")
              .help("The tree ID of the tree that you wish to prove consistency for. To use the default value, do not input any value."));
 
     let flags = matches.get_matches();
     let configuration = Configuration::default();
-    let pubkey = pubkey_api::get_public_key(&configuration, flags.value_of("tree_id")).await;
+    let pubkey = pubkey_api::get_public_key(
+        &configuration,
+        flags.get_one::<String>("tree_id").map(|s| s.as_str()),
+    )
+    .await;
     println!("{:#?}", pubkey.unwrap());
 }
diff --git a/examples/rekor/search_index/main.rs b/examples/rekor/search_index/main.rs
@@ -45,23 +45,23 @@ async fn main() {
     let matches = Command::new("cmd")
     .arg(Arg::new("hash")
              .long("hash")
-             .takes_value(true)
+             .value_name("HASH")
              .help("hash of the artifact"))
     .arg(Arg::new("url")
              .long("url")
-             .takes_value(true)
+             .value_name("URL")
              .help("url containing the contents of the artifact (raw github url)"))
     .arg(Arg::new("public_key")
              .long("public_key")
-             .takes_value(true)
+             .value_name("PUBLIC_KEY")
              .help("base64 encoded public_key. Look at https://raw.githubusercontent.com/jyotsna-penumaka/rekor-rs/rekor-functionality/test_data/create_log_entry.md for more details on generating keys."))
     .arg(Arg::new("key_format")
              .long("key_format")
-             .takes_value(true)
+             .value_name("KEY_FORMAT")
              .help("Accepted formats are : pgp / x509 / minsign / ssh / tuf"))  
      .arg(Arg::new("email")
              .long("email")
-             .takes_value(true)
+             .value_name("EMAIL")
              .help("Author's email"));
 
     let flags = matches.get_matches();
@@ -72,7 +72,11 @@ async fn main() {
     const KEY_FORMAT: &str = "x509";
     const EMAIL: &str = "jpenumak@redhat.com";
 
-    let key_format = match flags.value_of("key_format").unwrap_or(KEY_FORMAT) {
+    let key_format = match flags
+        .get_one::<String>("key_format")
+        .unwrap_or(&KEY_FORMAT.to_string())
+        .as_str()
+    {
         "pgp" => Format::Pgp,
         "x509" => Format::X509,
         "minisign" => Format::Minisign,
@@ -84,17 +88,27 @@ async fn main() {
         format: key_format,
         content: Some(
             flags
-                .value_of("public_key")
-                .unwrap_or(PUBLIC_KEY)
-                .to_string(),
+                .get_one::<String>("public_key")
+                .unwrap_or(&PUBLIC_KEY.to_string())
+                .to_owned(),
         ),
         url: None,
     };
 
     let query = SearchIndex {
-        email: Some(flags.value_of("email").unwrap_or(EMAIL).to_string()),
+        email: Some(
+            flags
+                .get_one::<String>("email")
+                .unwrap_or(&EMAIL.to_string())
+                .to_owned(),
+        ),
         public_key: Some(public_key),
-        hash: Some(flags.value_of("hash").unwrap_or(HASH).to_string()),
+        hash: Some(
+            flags
+                .get_one("hash")
+                .unwrap_or(&HASH.to_string())
+                .to_owned(),
+        ),
     };
     let configuration = Configuration::default();
 
diff --git a/examples/rekor/search_log_query/main.rs b/examples/rekor/search_log_query/main.rs
@@ -53,77 +53,85 @@ async fn main() {
     let matches = Command::new("cmd")
     .arg(Arg::new("hash")
              .long("hash")
-             .takes_value(true)
+             .value_name("HASH")
              .help("hash of the artifact"))
     .arg(Arg::new("url")
              .long("url")
-             .takes_value(true)
+             .value_name("URL")
              .help("url containing the contents of the artifact (raw github url)"))
     .arg(Arg::new("public_key")
              .long("public_key")
-             .takes_value(true)
+             .value_name("PUBLIC_KEY")
              .help("base64 encoded public_key. Look at https://raw.githubusercontent.com/jyotsna-penumaka/rekor-rs/rekor-functionality/test_data/create_log_entry.md for more details on generating keys."))
     .arg(Arg::new("key_format")
              .long("key_format")
-             .takes_value(true)
+             .value_name("KEY_FORMAT")
              .help("Accepted formats are : pgp / x509 / minsign / ssh / tuf"))
     .arg(Arg::new("signature")
              .long("signature")
-             .takes_value(true)
+             .value_name("SIGNATURE")
              .help("base64 encoded signature of the artifact. Look at https://raw.githubusercontent.com/jyotsna-penumaka/rekor-rs/rekor-functionality/test_data/create_log_entry.md for more details on generating keys."))
     .arg(Arg::new("api_version")
              .long("api_version")
-             .takes_value(true)
+             .value_name("API_VERSION")
              .help("Rekor-rs open api version"))
     .arg(Arg::new("entry_uuids")
              .long("entry_uuids")
-             .takes_value(true)
+             .value_name("ENTRY_UUIDS")
              .help("the uuids of the entries to search for"))
     .arg(Arg::new("log_indexes")
             .long("log_indexes")
-            .takes_value(true)
+            .value_name("LOG_INDEXES")
             .help("the log_indexes of the entries to search for"));
 
     let flags = matches.get_matches();
 
     let hash = Hash::new(
         AlgorithmKind::sha256,
-        flags.value_of("hash").unwrap_or(HASH).to_string(),
+        flags
+            .get_one::<String>("hash")
+            .unwrap_or(&HASH.to_string())
+            .to_owned(),
     );
     let data = Data::new(
         hash,
-        Url::parse(flags.value_of("url").unwrap_or(URL)).unwrap(),
+        Url::parse(flags.get_one::<String>("url").unwrap_or(&URL.to_string())).unwrap(),
     );
     let public_key = PublicKey::new(
         flags
-            .value_of("public_key")
-            .unwrap_or(PUBLIC_KEY)
-            .to_string(),
+            .get_one::<String>("public_key")
+            .unwrap_or(&PUBLIC_KEY.to_string())
+            .to_owned(),
     );
     let signature = Signature::new(
         flags
-            .value_of("key_format")
-            .unwrap_or(KEY_FORMAT)
-            .to_string(),
-        flags.value_of("signature").unwrap_or(SIGNATURE).to_string(),
+            .get_one::<String>("key_format")
+            .unwrap_or(&KEY_FORMAT.to_string())
+            .to_owned(),
+        flags
+            .get_one::<String>("signature")
+            .unwrap_or(&SIGNATURE.to_string())
+            .to_owned(),
         public_key,
     );
     let spec = Spec::new(signature, data);
     let proposed_entry = ProposedEntry::Hashedrekord {
         api_version: flags
-            .value_of("api_version")
-            .unwrap_or(API_VERSION)
-            .to_string(),
-        spec: spec,
+            .get_one::<String>("api_version")
+            .unwrap_or(&API_VERSION.to_string())
+            .to_owned(),
+        spec,
     };
 
     let query = SearchLogQuery {
         entry_uuids: Some(vec![flags
-            .value_of("entry_uuids")
-            .unwrap_or(ENTRY_UUIDS)
-            .to_string()]),
+            .get_one::<String>("entry_uuids")
+            .unwrap_or(&ENTRY_UUIDS.to_string())
+            .to_owned()]),
         log_indexes: Some(vec![i32::from_str(
-            flags.value_of("log_indexes").unwrap_or(LOG_INDEXES),
+            flags
+                .get_one::<String>("log_indexes")
+                .unwrap_or(&LOG_INDEXES.to_string()),
         )
         .unwrap()]),
         entries: Some(vec![proposed_entry]),
diff --git a/src/lib.rs b/src/lib.rs
