Upgrade dependencies, clap in CLI

Author: joepio

Cargo.lock

@@ -6,11 +6,11 @@ license = "MIT"
 name = "atomic-cli"
 readme = "README.md"
 repository = "https://github.com/atomicdata-dev/atomic-data-rust"
-version = "0.34.2"
+version = "0.34.3"
 
 [dependencies]
-atomic_lib = {version = "0.34.2", path = "../lib", features = ["config", "rdf"]}
-clap = {version = "3", features = ["cargo"]}
+atomic_lib = {version = "0.34.3", path = "../lib", features = ["config", "rdf"]}
+clap = {version = "4", features = ["cargo"]}
 colored = "2"
 dirs = "4"
 edit = {version = "0.1", optional = true}

cli/Cargo.toml

@@ -62,23 +62,23 @@ fn argument_to_string(context: &Context, argument: &str) -> AtomicResult<String>
     let command_name = context.matches.subcommand_name().unwrap();
     let subcommand_matches = context.matches.subcommand_matches(command_name).unwrap();
     let user_arg = subcommand_matches
-        .value_of(argument)
+        .get_one::<&str>(argument)
         .ok_or(format!("No argument value for {} found", argument))?;
-    Ok(user_arg.into())
+    Ok(user_arg.to_string())
 }
 
 /// Parses a single argument (URL or Bookmark), should return a valid URL
 fn argument_to_url(context: &Context, argument: &str) -> AtomicResult<String> {
     let command_name = context.matches.subcommand_name().unwrap();
     let subcommand_matches = context.matches.subcommand_matches(command_name).unwrap();
     let user_arg = subcommand_matches
-        .value_of(argument)
+        .get_one::<&str>(argument)
         .ok_or(format!("No argument value for {} found", argument))?;
     let id_url: String = context
         .mapping
         .lock()
         .unwrap()
-        .try_mapping_or_url(&String::from(user_arg))
+        .try_mapping_or_url(&String::from(user_arg.to_string()))
         .ok_or(&*format!("No url found for {}", user_arg))?;
     Ok(id_url)
 }

cli/src/commit.rs

@@ -105,14 +105,14 @@ fn main() -> AtomicResult<()> {
                     ",
                     )
                     .required(true)
-                    .min_values(1)
+                    .num_args(1..)
                 )
                 .arg(Arg::new("as")
                     .long("as")
-                    .possible_values(SERIALIZE_OPTIONS)
+                    .value_parser(SERIALIZE_OPTIONS)
                     .default_value("pretty")
                     .help("Serialization format")
-                    .takes_value(true)
+                    .num_args(1)
                 )
         )
         .subcommand(
@@ -138,10 +138,10 @@ fn main() -> AtomicResult<()> {
                 )
                 .arg(Arg::new("as")
                     .long("as")
-                    .possible_values(SERIALIZE_OPTIONS)
+                    .value_parser(SERIALIZE_OPTIONS)
                     .default_value("pretty")
                     .help("Serialization format")
-                    .takes_value(true)
+                    .num_args(1)
                 )
         )
         .subcommand(
@@ -294,9 +294,9 @@ fn list(context: &mut Context) {
 /// Triple Pattern Fragment Query
 fn tpf(context: &Context) -> AtomicResult<()> {
     let subcommand_matches = context.matches.subcommand_matches("tpf").unwrap();
-    let subject = tpf_value(subcommand_matches.value_of("subject").unwrap());
-    let property = tpf_value(subcommand_matches.value_of("property").unwrap());
-    let value = tpf_value(subcommand_matches.value_of("value").unwrap());
+    let subject = tpf_value(subcommand_matches.get_one::<&str>("subject").unwrap());
+    let property = tpf_value(subcommand_matches.get_one::<&str>("property").unwrap());
+    let value = tpf_value(subcommand_matches.get_one::<&str>("value").unwrap());
     let endpoint = format!("{}/tpf", &context.get_write_context().server);
     let resources =
         atomic_lib::client::fetch_tpf(&endpoint, subject, property, value, &context.store)?;

cli/src/main.rs

@@ -18,7 +18,7 @@ pub fn new(context: &mut Context) -> AtomicResult<()> {
         .matches
         .subcommand_matches("new")
         .unwrap()
-        .value_of("class")
+        .get_one::<&str>("class")
         .expect("Add a class value");
     let class_url = context
         .mapping

cli/src/new.rs

@@ -8,9 +8,10 @@ use serialize::Format;
 /// Resolves an Atomic Path query
 pub fn get_path(context: &mut Context) -> AtomicResult<()> {
     let subcommand_matches = context.matches.subcommand_matches("get").unwrap();
-    let path_vec: Vec<&str> = subcommand_matches
-        .values_of("path")
+    let path_vec: Vec<String> = subcommand_matches
+        .get_many::<String>("path")
         .expect("Add a URL, shortname or path")
+        .map(|s| s.to_string())
         .collect();
     let path_string: String = path_vec.join(" ");
     let serialization: Format = get_serialization(subcommand_matches)?;

cli/src/path.rs

@@ -14,8 +14,8 @@ pub const SERIALIZE_OPTIONS: [&str; 7] =
 
 /// Returns preferred serialization format. Defaults to pretty.
 pub fn get_serialization(argmatches: &ArgMatches) -> AtomicResult<Format> {
-    let format = if let Some(preferred_format) = argmatches.value_of("as") {
-        match preferred_format {
+    let format = if let Some(preferred_format) = argmatches.get_one::<String>("as") {
+        match preferred_format.as_str() {
             "pretty" => Format::Pretty,
             "json" => Format::Json,
             "jsonld" => Format::JsonLd,

cli/src/print.rs

@@ -16,7 +16,7 @@ name = "benchmarks"
 # path = "benches/benchmarks.rs"
 
 [dependencies]
-base64 = "0.13"
+base64 = "0.21"
 bincode = {version = "1", optional = true}
 directories = {version = ">= 2, < 5", optional = true}
 html2md = {version = "0.2.13", optional = true}
@@ -25,22 +25,22 @@ lol_html = {version = "0.3.1", optional = true}
 rand = {version = "0.8"}
 regex = "1"
 ring = "0.16.19"
-rio_api = {version = "0.7", optional = true}
-rio_turtle = {version = "0.7", optional = true}
+rio_api = {version = "0.8", optional = true}
+rio_turtle = {version = "0.8", optional = true}
 serde = {version = "1", features = ["derive"]}
 serde_json = "1"
 sled = {version = "0.34", optional = true, features = ["no_logs"]}
-toml = {version = "0.5", optional = true}
+toml = {version = "0.7", optional = true}
 tracing = "0.1"
 ureq = "2"
 url = "2"
 urlencoding = "2"
 
 [dev-dependencies]
-criterion = "0.3"
+criterion = "0.4"
 iai = "0.1"
 lazy_static = "1"
-ntest = "0.7"
+ntest = "0.9"
 
 [features]
 config = ["directories", "toml"]

lib/Cargo.toml

@@ -2,6 +2,8 @@
 //! Agents are actors (such as users) that can edit content.
 //! https://docs.atomicdata.dev/commits/concepts.html
 
+use base64::{engine::general_purpose, Engine};
+
 use crate::{errors::AtomicResult, urls, Resource, Storelike, Value};
 
 #[derive(Clone, Debug)]
@@ -93,28 +95,39 @@ fn generate_keypair() -> AtomicResult<Pair> {
         .map_err(|e| format!("Error generating keypair {}", e))
         .unwrap();
     Ok(Pair {
-        private: base64::encode(seed),
-        public: base64::encode(key_pair.public_key()),
+        private: encode_base64(&seed),
+        public: encode_base64(key_pair.public_key().as_ref()),
     })
 }
 
 /// Returns a Key Pair (including public key) from a private key, base64 encoded.
 pub fn generate_public_key(private_key: &str) -> Pair {
     use ring::signature::KeyPair;
-    let private_key_bytes = base64::decode(private_key).unwrap();
+    let private_key_bytes = decode_base64(private_key).unwrap();
     let key_pair = ring::signature::Ed25519KeyPair::from_seed_unchecked(private_key_bytes.as_ref())
         .map_err(|_| "Error generating keypair")
         .unwrap();
     Pair {
-        private: base64::encode(private_key_bytes),
-        public: base64::encode(key_pair.public_key().as_ref()),
+        private: encode_base64(&private_key_bytes),
+        public: encode_base64(key_pair.public_key().as_ref()),
     }
 }
 
+pub fn decode_base64(string: &str) -> AtomicResult<Vec<u8>> {
+    let vec = general_purpose::STANDARD
+        .decode(string)
+        .map_err(|e| format!("Invalid key. Not valid Base64. {}", e))?;
+    Ok(vec)
+}
+
+pub fn encode_base64(bytes: &[u8]) -> String {
+    general_purpose::STANDARD.encode(bytes)
+}
+
 /// Checks if the public key is a valid ED25519 base64 key.
 /// Not perfect - only checks byte length and parses base64.
 pub fn verify_public_key(public_key: &str) -> AtomicResult<()> {
-    let pubkey_bin = base64::decode(public_key)
+    let pubkey_bin = decode_base64(public_key)
         .map_err(|e| format!("Invalid public key. Not valid Base64. {}", e))?;
     if pubkey_bin.len() != 32 {
         return Err(format!(

lib/src/agents.rs

@@ -1,6 +1,8 @@
 //! Check signatures in authentication headers, find the correct agent. Authorization is done in Hierarchies
 
-use crate::{commit::check_timestamp, errors::AtomicResult, urls, Storelike};
+use crate::{
+    agents::decode_base64, commit::check_timestamp, errors::AtomicResult, urls, Storelike,
+};
 
 /// Set of values extracted from the request.
 /// Most are coming from headers.
@@ -26,11 +28,11 @@ pub struct AuthValues {
 /// Does not check if the agent has rights to access the subject.
 #[tracing::instrument(skip_all)]
 pub fn check_auth_signature(subject: &str, auth_header: &AuthValues) -> AtomicResult<()> {
-    let agent_pubkey = base64::decode(&auth_header.public_key)?;
+    let agent_pubkey = decode_base64(&auth_header.public_key)?;
     let message = format!("{} {}", subject, &auth_header.timestamp);
     let peer_public_key =
         ring::signature::UnparsedPublicKey::new(&ring::signature::ED25519, agent_pubkey);
-    let signature_bytes = base64::decode(&auth_header.signature)?;
+    let signature_bytes = decode_base64(&auth_header.signature)?;
     peer_public_key
                 .verify(message.as_bytes(), &signature_bytes)
                 .map_err(|_e| {