Merge pull request #128 from wa5i/clippy

fix: make clippy happy

Author: Paul Yang

src/api/client.rs

@@ -157,7 +157,7 @@ impl Client {
     }
 
     pub fn request(&self, method: &str, path: &str, data: Option<Map<String, Value>>) -> Result<HttpResponse, RvError> {
-        let url = if path.starts_with("/") {
+        let url = if path.starts_with('/') {
             format!("{}{}", self.address, path)
         } else {
             format!("{}/{}", self.address, path)

src/cli/command/server.rs

@@ -88,7 +88,7 @@ impl Server {
 
         let mut work_dir = WORK_DIR_PATH_DEFAULT.to_string();
         if !config.work_dir.is_empty() {
-            work_dir = config.work_dir.clone();
+            work_dir.clone_from(&config.work_dir);
         }
 
         if !Path::new(work_dir.as_str()).exists() {
@@ -101,18 +101,18 @@ impl Server {
             // start daemon
             let log_path = format!("{}/rusty_vault.log", work_dir);
             let mut pid_path = config.pid_file.clone();
-            if !config.pid_file.starts_with("/") {
+            if !config.pid_file.starts_with('/') {
                 pid_path = work_dir.clone() + pid_path.as_str();
             }
 
             let mut user = "onbody".to_owned();
             if !config.daemon_user.is_empty() {
-                user = config.daemon_user.clone();
+                user.clone_from(&config.daemon_user);
             }
 
             let mut group = "onbody".to_owned();
             if !config.daemon_group.is_empty() {
-                group = config.daemon_group.clone();
+                group.clone_from(&config.daemon_group);
             }
 
             let log_file = std::fs::OpenOptions::new()

src/cli/config.rs

@@ -312,8 +312,8 @@ fn load_config_file(path: &str) -> Result<Config, RvError> {
 }
 
 fn set_config_type_field(config: &mut Config) -> Result<(), RvError> {
-    config.storage.iter_mut().for_each(|(key, value)| value.stype = key.clone());
-    config.listener.iter_mut().for_each(|(key, value)| value.ltype = key.clone());
+    config.storage.iter_mut().for_each(|(key, value)| value.stype.clone_from(key));
+    config.listener.iter_mut().for_each(|(key, value)| value.ltype.clone_from(key));
     Ok(())
 }
 

src/http/logical.rs

@@ -52,11 +52,11 @@ async fn logical_request_handler(
     let mut req_conn = ReqConnection::default();
     req_conn.peer_addr = conn.peer.to_string();
     if conn.tls.is_some() {
-        req_conn.peer_tls_cert = conn.tls.as_ref().unwrap().client_cert_chain.clone();
+        req_conn.peer_tls_cert.clone_from(&conn.tls.as_ref().unwrap().client_cert_chain);
     }
 
     let mut r = request_auth(&req);
-    r.path = path.into_inner().clone();
+    r.path.clone_from(&path.into_inner());
     r.connection = Some(req_conn);
 
     match method {
@@ -103,7 +103,7 @@ fn response_logical(resp: &Response, path: &str) -> Result<HttpResponse, RvError
     let mut no_content = true;
 
     if let Some(ref secret) = &resp.secret {
-        logical_resp.lease_id = secret.lease_id.clone();
+        logical_resp.lease_id.clone_from(&secret.lease_id);
         logical_resp.renewable = secret.lease.renewable;
         logical_resp.lease_duration = secret.lease.ttl.as_secs();
         no_content = false;

src/logical/request.rs

@@ -174,15 +174,15 @@ impl Request {
         if self.data.is_some() {
             if let Some(secret_str) = self.data.as_mut().unwrap().get_mut(key) {
                 if let Value::String(ref mut s) = *secret_str {
-                    *s = "".to_owned();
+                    "".clone_into(s);
                 }
             }
         }
 
         if self.body.is_some() {
             if let Some(secret_str) = self.body.as_mut().unwrap().get_mut(key) {
                 if let Value::String(ref mut s) = *secret_str {
-                    *s = "".to_owned();
+                    "".clone_into(s);
                 }
             }
         }

src/logical/secret.rs

@@ -40,7 +40,7 @@ impl Secret {
         let mut secret = SecretData { lease, lease_id: String::new(), internal_data: Map::new() };
 
         if internal.is_some() {
-            secret.internal_data = internal.as_ref().unwrap().clone();
+            secret.internal_data.clone_from(internal.as_ref().unwrap());
         }
 
         secret.internal_data.insert("secret_type".to_owned(), Value::String(self.secret_type.clone()));

src/modules/auth/expiration.rs

@@ -227,7 +227,7 @@ impl ExpirationManager {
 
         le.data = resp.data.clone().unwrap_or(Map::new());
         le.expire_time = resp.secret.as_ref().unwrap().expiration_time();
-        le.secret = resp.secret.clone();
+        le.secret.clone_from(&resp.secret);
 
         self.persist_lease_entry(&le)?;
         self.register_lease_entry(Arc::new(le))?;
@@ -278,7 +278,7 @@ impl ExpirationManager {
             auth.explicit_max_ttl,
             le.issue_time,
         )?;
-        auth.client_token = te.id.clone();
+        auth.client_token.clone_from(&te.id);
 
         le.expire_time = auth.expiration_time();
         le.auth = Some(auth.clone());
@@ -305,7 +305,7 @@ impl ExpirationManager {
 
             let lease_id = format!("{}/{}", req.path, generate_uuid());
 
-            secret.lease_id = lease_id.clone();
+            secret.lease_id.clone_from(&lease_id);
 
             let le = LeaseEntry {
                 lease_id: lease_id.clone(),
@@ -401,7 +401,7 @@ impl ExpirationManager {
     /// Revokes all lease entries with a given prefix.
     pub fn revoke_prefix(&self, prefix: &str) -> Result<(), RvError> {
         let mut prefix = prefix.to_string();
-        if !prefix.ends_with("/") {
+        if !prefix.ends_with('/') {
             prefix += "/";
         }
 
@@ -655,7 +655,7 @@ impl ExpirationManager {
         if le.auth.is_some() {
             let mut au = le.auth.as_ref().unwrap().clone();
             if le.path.starts_with("auth/token/") {
-                au.client_token = le.client_token.clone();
+                au.client_token.clone_from(&le.client_token);
             } else {
                 au.client_token = "".to_string();
             }

src/modules/auth/mod.rs

@@ -87,7 +87,7 @@ impl AuthModule {
             let mut auth_table = router_store.mounts.entries.write()?;
             let mut entry = me.clone();
 
-            if !entry.path.ends_with("/") {
+            if !entry.path.ends_with('/') {
                 entry.path += "/";
             }
 
@@ -142,7 +142,7 @@ impl AuthModule {
         let router_store = self.router_store.read()?;
 
         let mut path = path.to_string();
-        if !path.ends_with("/") {
+        if !path.ends_with('/') {
             path += "/";
         }
 
@@ -172,11 +172,11 @@ impl AuthModule {
         let mut src = src.to_string();
         let mut dst = dst.to_string();
 
-        if !src.ends_with("/") {
+        if !src.ends_with('/') {
             src += "/";
         }
 
-        if !dst.ends_with("/") {
+        if !dst.ends_with('/') {
             dst += "/";
         }
 

src/modules/auth/token_store.rs

@@ -525,19 +525,19 @@ impl TokenStore {
             if !is_root {
                 return Err(RvError::ErrRequestInvalid);
             }
-            te.id = data.id.clone();
+            te.id.clone_from(&data.id);
         }
 
         if data.policies.is_empty() {
-            data.policies = parent.policies.clone();
+            data.policies.clone_from(&parent.policies);
             sanitize_policies(&mut data.policies, false);
         }
 
         if !is_root && !is_str_subset(&data.policies, &parent.policies) {
             return Err(RvError::ErrRequestInvalid);
         }
 
-        te.policies = data.policies.clone();
+        te.policies.clone_from(&data.policies);
 
         for policy in te.policies.iter() {
             if NON_ASSIGNABLE_POLICIES.contains(&policy.as_str()) {
@@ -657,7 +657,7 @@ impl TokenStore {
         log::debug!("lookup token");
         let mut id = req.get_data_as_str("token")?;
         if id.is_empty() {
-            id = req.client_token.clone();
+            id.clone_from(&req.client_token);
         }
 
         if id.is_empty() {
@@ -771,7 +771,7 @@ impl Handler for TokenStore {
             return Err(RvError::ErrPermissionDenied);
         }
 
-        req.name = auth.as_ref().unwrap().display_name.clone();
+        req.name.clone_from(&auth.as_ref().unwrap().display_name);
         req.auth = auth;
 
         req.handle_phase = HandlePhase::PostAuth;
@@ -826,9 +826,9 @@ impl Handler for TokenStore {
         if let Some(auth) = resp.auth.as_mut() {
             if is_unauth_path {
                 let source = self.router.matching_mount(&req.path)?;
-                let source = source.as_str().trim_start_matches(AUTH_ROUTER_PREFIX).replace("/", "-");
-                auth.display_name = (source + &auth.display_name).trim_end_matches("-").to_string();
-                req.name = auth.display_name.clone();
+                let source = source.as_str().trim_start_matches(AUTH_ROUTER_PREFIX).replace('/', "-");
+                auth.display_name = (source + &auth.display_name).trim_end_matches('-').to_string();
+                req.name.clone_from(&auth.display_name);
             } else if !req.path.starts_with("auth/token/") {
                 return Err(RvError::ErrPermissionDenied);
             }
@@ -852,7 +852,7 @@ impl Handler for TokenStore {
                 SystemTime::now(),
             )?;
 
-            auth.token_policies = auth.policies.clone();
+            auth.token_policies.clone_from(&auth.policies);
             sanitize_policies(&mut auth.token_policies, !auth.no_default_policy);
 
             let all_policies = auth.token_policies.clone();
@@ -876,7 +876,7 @@ impl Handler for TokenStore {
 
             self.create(&mut te)?;
 
-            auth.client_token = te.id.clone();
+            auth.client_token.clone_from(&te.id);
             auth.ttl = Duration::from_secs(te.ttl);
 
             self.expiration.register_auth(&te, auth)?;

src/modules/credential/approle/path_role.rs

@@ -916,6 +916,7 @@ or 'secret_id_ttl' option on the role, and/or the backend mount's maximum TTL va
     }
 }
 
+#[allow(clippy::assigning_clones)]
 impl AppRoleBackendInner {
     pub fn get_role_id(&self, req: &mut Request, role_id: &str) -> Result<Option<RoleIdEntry>, RvError> {
         if role_id.is_empty() {
@@ -995,7 +996,7 @@ impl AppRoleBackendInner {
         }
 
         if !role_entry.bound_cidr_list.is_empty() {
-            role_entry.secret_id_bound_cidrs = role_entry.bound_cidr_list.clone();
+            role_entry.secret_id_bound_cidrs.clone_from(&role_entry.bound_cidr_list);
             role_entry.bound_cidr_list.clear();
         }
 
@@ -1090,7 +1091,7 @@ impl AppRoleBackendInner {
             role_entry.policies = role_entry.token_policies.clone();
         } else if let Ok(policies_value) = req.get_data("policies") {
             let policies = policies_value.as_comma_string_slice().ok_or(RvError::ErrRequestFieldInvalid)?;
-            role_entry.policies = policies.clone();
+            role_entry.policies.clone_from(&policies);
             role_entry.token_policies = policies;
         }
 
@@ -1284,7 +1285,7 @@ impl AppRoleBackendInner {
 
         if let Some(mut role) = self.get_role(req, &role_name)? {
             sanitize_policies(&mut token_policies, false);
-            role.policies = token_policies.clone();
+            role.policies.clone_from(&token_policies);
             role.token_policies = token_policies;
             self.set_role(req, &role_name, &role, "")?;
         } else {
@@ -1455,7 +1456,7 @@ impl AppRoleBackendInner {
                     }
                 }
                 "role_id" => {
-                    previous_role_id = role.role_id.clone();
+                    previous_role_id.clone_from(&role.role_id);
                     role.role_id = field_value.as_str().ok_or(RvError::ErrLogicalOperationUnsupported)?.to_string();
                     if role.role_id.as_str() == "" {
                         return Err(RvError::ErrResponse("missing role_id".to_string()));
@@ -2090,7 +2091,7 @@ impl AppRoleBackendInner {
                 &role_name_hmac,
                 &accessor_entry.secret_id_hmac,
             )? {
-                let data = serde_json::to_value(&secret_id_entry)?;
+                let data = serde_json::to_value(secret_id_entry)?;
                 return Ok(Some(Response::data_response(Some(data.as_object().unwrap().clone()))));
             }
         } else {