Fix lints in aries_vcx (#989)

Addressed lints and formatting in aries_vcx.

Signed-off-by: Bogdan Mircea <mirceapetrebogdan@gmail.com>

aries_vcx/src/common/anoncreds.rs

@@ -26,7 +26,7 @@ pub mod integration_tests {
             let proof_req = "{";
             let anoncreds = Arc::clone(&setup.profile).inject_anoncreds();
             let result = anoncreds
-                .prover_get_credentials_for_proof_req(&proof_req)
+                .prover_get_credentials_for_proof_req(proof_req)
                 .await;
             assert_eq!(
                 result.unwrap_err().kind(),

aries_vcx/src/common/ledger/transactions.rs

@@ -107,9 +107,8 @@ pub async fn into_did_doc(
     let mut did_doc: AriesDidDoc = AriesDidDoc::default();
     let (service_endpoint, recipient_keys, routing_keys) = match invitation {
         AnyInvitation::Con(Invitation {
-            id,
             content: InvitationContent::Public(content),
-            decorators,
+            ..
         }) => {
             did_doc.set_id(content.did.to_string());
             let service = get_service(indy_ledger, &content.did)
@@ -130,7 +129,7 @@ pub async fn into_did_doc(
         AnyInvitation::Con(Invitation {
             id,
             content: InvitationContent::Pairwise(content),
-            decorators,
+            ..
         }) => {
             did_doc.set_id(id.clone());
             (
@@ -140,13 +139,12 @@ pub async fn into_did_doc(
             )
         }
         AnyInvitation::Con(Invitation {
-            id,
-            content: InvitationContent::PairwiseDID(content),
-            decorators,
+            content: InvitationContent::PairwiseDID(_content),
+            ..
         }) => {
             return Err(AriesVcxError::from_msg(
                 AriesVcxErrorKind::InvalidDid,
-                format!("PairwiseDID invitation not supported yet!"),
+                "PairwiseDID invitation not supported yet!",
             ))
         }
         AnyInvitation::Oob(invitation) => {
@@ -336,7 +334,7 @@ pub async fn add_attr(
     did: &str,
     attr: &str,
 ) -> VcxResult<()> {
-    let res = indy_ledger_write.add_attr(did, &attr).await?;
+    let res = indy_ledger_write.add_attr(did, attr).await?;
     check_response(&res)
 }
 
@@ -365,7 +363,7 @@ pub async fn clear_attr(
         .map_err(|err| err.into())
 }
 
-pub(self) fn check_response(response: &str) -> VcxResult<()> {
+fn check_response(response: &str) -> VcxResult<()> {
     if settings::indy_mocks_enabled() {
         return Ok(());
     }

aries_vcx/src/common/primitives/credential_definition.rs

@@ -1,4 +1,4 @@
-use std::{fmt, sync::Arc};
+use std::sync::Arc;
 
 use aries_vcx_core::{
     anoncreds::base_anoncreds::BaseAnonCreds,
@@ -15,62 +15,40 @@ use crate::{
     },
 };
 
-macro_rules! enum_number {
-    ($name:ident { $($variant:ident = $value:expr, )* }) => {
-        #[derive(Clone, Copy, Debug, Eq, PartialEq)]
-        pub enum $name {
-            $($variant = $value,)*
-        }
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Deserialize, Default)]
+#[serde(try_from = "u8")]
+#[repr(u8)]
+pub enum PublicEntityStateType {
+    Built = 0,
+    #[default]
+    Published = 1,
+}
 
-        impl ::serde::Serialize for $name {
-            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-                where S: ::serde::Serializer
-            {
-                // Serialize the enum as a u64.
-                serializer.serialize_u64(*self as u64)
-            }
-        }
+impl ::serde::Serialize for PublicEntityStateType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: ::serde::Serializer,
+    {
+        serializer.serialize_u8(*self as u8)
+    }
+}
 
-        impl<'de> ::serde::Deserialize<'de> for $name {
-            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-                where D: ::serde::Deserializer<'de>
-            {
-                struct Visitor;
-
-                impl<'de> ::serde::de::Visitor<'de> for Visitor {
-                    type Value = $name;
-
-                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                        formatter.write_str("positive integer")
-                    }
-
-                    fn visit_u64<E>(self, value: u64) -> Result<$name, E>
-                        where E: ::serde::de::Error
-                    {
-                        // Rust does not come with a simple way of converting a
-                        // number to an enum, so use a big `match`.
-                        match value {
-                            $( $value => Ok($name::$variant), )*
-                            _ => Err(E::custom(
-                                format!("unknown {} value: {}",
-                                stringify!($name), value))),
-                        }
-                    }
-                }
-
-                // Deserialize the enum from a u64.
-                deserializer.deserialize_u64(Visitor)
-            }
+impl TryFrom<u8> for PublicEntityStateType {
+    type Error = String;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(PublicEntityStateType::Built),
+            1 => Ok(PublicEntityStateType::Published),
+            _ => Err(format!(
+                "unknown {} value: {}",
+                stringify!(PublicEntityStateType),
+                value
+            )),
         }
     }
 }
 
-enum_number!(PublicEntityStateType
-{
-    Built = 0,
-    Published = 1,
-});
-
 #[derive(Clone, Deserialize, Debug, Serialize, PartialEq, Eq, Default)]
 pub struct CredentialDef {
     #[serde(alias = "cred_def_id")]
@@ -102,12 +80,6 @@ pub struct RevocationDetails {
     pub max_creds: Option<u32>,
 }
 
-impl Default for PublicEntityStateType {
-    fn default() -> Self {
-        PublicEntityStateType::Published
-    }
-}
-
 async fn _try_get_cred_def_from_ledger(
     ledger: &Arc<dyn AnoncredsLedgerRead>,
     issuer_did: &str,
@@ -193,7 +165,7 @@ impl CredentialDef {
             self.id
         );
         if let Some(ledger_cred_def_json) =
-            _try_get_cred_def_from_ledger(&ledger_read, &self.issuer_did, &self.id).await?
+            _try_get_cred_def_from_ledger(ledger_read, &self.issuer_did, &self.id).await?
         {
             return Err(AriesVcxError::from_msg(
                 AriesVcxErrorKind::CredDefAlreadyCreated,

aries_vcx/src/common/primitives/revocation_registry_delta.rs

@@ -1,7 +1,3 @@
-use std::sync::Arc;
-
-use aries_vcx_core::ledger::base_ledger::AnoncredsLedgerRead;
-
 use crate::errors::error::prelude::*;
 
 #[derive(Clone, Deserialize, Debug, Serialize, Default)]
@@ -34,7 +30,7 @@ impl RevocationRegistryDeltaValue {
 
 impl RevocationRegistryDelta {
     pub async fn create_from_ledger(rev_reg_delta_json: &str) -> VcxResult<Self> {
-        serde_json::from_str(&rev_reg_delta_json).map_err(|err| {
+        serde_json::from_str(rev_reg_delta_json).map_err(|err| {
             AriesVcxError::from_msg(
                 AriesVcxErrorKind::SerializationError,
                 format!(

aries_vcx/src/common/proofs/proof_request.rs

@@ -328,7 +328,7 @@ mod unit_tests {
         let request = ProofRequestData::create(&anoncreds, "")
             .await
             .unwrap()
-            .set_requested_attributes_as_string(requested_attrs.into())
+            .set_requested_attributes_as_string(requested_attrs)
             .unwrap();
 
         let mut expected_req_attrs: HashMap<String, AttrInfo> = HashMap::new();
@@ -359,7 +359,7 @@ mod unit_tests {
         let err = ProofRequestData::create(&anoncreds, "")
             .await
             .unwrap()
-            .set_requested_attributes_as_string(requested_attrs.into())
+            .set_requested_attributes_as_string(requested_attrs)
             .unwrap_err();
 
         assert_eq!(AriesVcxErrorKind::InvalidProofRequest, err.kind());

aries_vcx/src/common/proofs/prover/prover_internal.rs

@@ -112,7 +112,7 @@ pub fn credential_def_identifiers(
             credential_referent: cred_info.referent.clone(),
             schema_id: cred_info.schema_id.clone(),
             cred_def_id: cred_info.cred_def_id.clone(),
-            revocation_interval: _get_revocation_interval(&referent, proof_req)?,
+            revocation_interval: _get_revocation_interval(referent, proof_req)?,
             timestamp: None,
             rev_reg_id: cred_info.rev_reg_id.clone(),
             cred_rev_id: cred_info.cred_rev_id.clone(),
@@ -337,17 +337,14 @@ pub mod unit_tests {
     use aries_vcx_core::ledger::indy::pool::test_utils::get_temp_dir_path;
 
     use super::*;
-    use crate::{
-        core::profile::vdrtools_profile::VdrtoolsProfile,
-        utils::{
-            constants::{
-                ADDRESS_CRED_DEF_ID, ADDRESS_CRED_ID, ADDRESS_CRED_REV_ID, ADDRESS_REV_REG_ID,
-                ADDRESS_SCHEMA_ID, CRED_DEF_ID, CRED_REV_ID, LICENCE_CRED_ID, REV_REG_ID,
-                REV_STATE_JSON, SCHEMA_ID,
-            },
-            devsetup::*,
-            mockdata::profile::{mock_anoncreds::MockAnoncreds, mock_ledger::MockLedger},
+    use crate::utils::{
+        constants::{
+            ADDRESS_CRED_DEF_ID, ADDRESS_CRED_ID, ADDRESS_CRED_REV_ID, ADDRESS_REV_REG_ID,
+            ADDRESS_SCHEMA_ID, CRED_DEF_ID, CRED_REV_ID, LICENCE_CRED_ID, REV_REG_ID,
+            REV_STATE_JSON, SCHEMA_ID,
         },
+        devsetup::*,
+        mockdata::profile::{mock_anoncreds::MockAnoncreds, mock_ledger::MockLedger},
     };
 
     fn proof_req_no_interval() -> ProofRequestData {
@@ -401,7 +398,7 @@ pub mod unit_tests {
         let credential_def = build_cred_defs_json_prover(&ledger_read, &creds)
             .await
             .unwrap();
-        assert!(credential_def.len() > 0);
+        assert!(!credential_def.is_empty());
         assert!(credential_def
             .contains(r#""id":"V4SGRU86Z58d6TV7PBUe6f:3:CL:47:tag1","schemaId":"47""#));
     }
@@ -448,7 +445,7 @@ pub mod unit_tests {
         let schemas = build_schemas_json_prover(&ledger_read, &creds)
             .await
             .unwrap();
-        assert!(schemas.len() > 0);
+        assert!(!schemas.is_empty());
         assert!(schemas.contains(
             r#""id":"2hoqvcwupRTUNkXn6ArYzs:2:test-licence:4.4.4","name":"test-licence""#
         ));
@@ -691,7 +688,7 @@ pub mod unit_tests {
                 "zip_2": { "name": "zip_2" }
             },
             "requested_predicates": {},
-            "non_revoked": {"from": 098, "to": 123}
+            "non_revoked": {"from": 98, "to": 123}
         });
         let proof_req: ProofRequestData = serde_json::from_value(proof_req).unwrap();
         let requested_credential = build_requested_credentials_json(
@@ -747,7 +744,7 @@ pub mod unit_tests {
                 "zip_2": { "name": "zip" }
             },
             "requested_predicates": {},
-            "non_revoked": {"from": 098, "to": 123}
+            "non_revoked": {"from": 98, "to": 123}
         });
         let proof_req: ProofRequestData = serde_json::from_value(proof_req).unwrap();
 
@@ -771,7 +768,7 @@ pub mod unit_tests {
 
         // when attribute interval is None, defaults to proof req interval
         let interval = Some(NonRevokedInterval {
-            from: Some(098),
+            from: Some(98),
             to: Some(123),
         });
         assert_eq!(