replaced unused format! by .to_string

AxelNennker · AxelNennker · commit 275da9ce183e · 2018-06-01T22:50:45.000+02:00
Signed-off-by: Axel Nennker &lt;axel.nennker@telekom.de&gt;
diff --git a/libindy/src/commands/anoncreds/issuer.rs b/libindy/src/commands/anoncreds/issuer.rs
@@ -187,7 +187,7 @@ impl IssuerCommandExecutor {
             .map_err(|err| CommonError::InvalidStructure(format!("Cannot deserialize AttributeNames: {:?}", err)))?;
 
         if attrs.is_empty() {
-            return Err(IndyError::CommonError(CommonError::InvalidStructure(format!("List of Schema attributes is empty"))));
+            return Err(IndyError::CommonError(CommonError::InvalidStructure("List of Schema attributes is empty".to_string())));
         }
 
         let schema_id = Schema::schema_id(issuer_did, name, version);
@@ -440,15 +440,15 @@ impl IssuerCommandExecutor {
                 rev_reg_info.curr_id = 1 + rev_reg_info.curr_id;
 
                 if rev_reg_info.curr_id > rev_reg_def.value.max_cred_num {
-                    return Err(IndyError::AnoncredsError(AnoncredsError::RevocationRegistryFull(format!("RevocationRegistryAccumulator is full"))));
+                    return Err(IndyError::AnoncredsError(AnoncredsError::RevocationRegistryFull("RevocationRegistryAccumulator is full".to_string())));
                 }
 
                 if rev_reg_def.value.issuance_type == IssuanceType::ISSUANCE_ON_DEMAND {
                     rev_reg_info.used_ids.insert(rev_reg_info.curr_id.clone());
                 }
 
                 let blob_storage_reader_handle = blob_storage_reader_handle
-                    .ok_or(IndyError::CommonError(CommonError::InvalidStructure(format!("TailsReaderHandle not found"))))?;
+                    .ok_or(IndyError::CommonError(CommonError::InvalidStructure("TailsReaderHandle not found".to_string())))?;
 
                 let sdk_tails_accessor = SDKTailsAccessor::new(self.blob_storage_service.clone(),
                                                                blob_storage_reader_handle,
@@ -695,4 +695,4 @@ impl IssuerCommandExecutor {
     fn _wallet_get_rev_reg_info(&self, wallet_handle: i32, key: &str) -> Result<RevocationRegistryInfo, WalletError> {
         self.wallet_service.get_indy_object(wallet_handle, &key, &RecordOptions::id_value(), &mut String::new())
     }
-}
+}
diff --git a/libindy/src/commands/anoncreds/tails.rs b/libindy/src/commands/anoncreds/tails.rs
@@ -28,7 +28,7 @@ impl SDKTailsAccessor {
                tails_reader_handle: i32,
                rev_reg_def: &RevocationRegistryDefinitionV1) -> Result<SDKTailsAccessor, CommonError> {
         let tails_hash = rev_reg_def.value.tails_hash.from_base58()
-            .map_err(|_| CommonError::InvalidState(format!("Invalid base58 for Tails hash")))?;
+            .map_err(|_| CommonError::InvalidState("Invalid base58 for Tails hash".to_string()))?;
 
         let tails_reader_handle = tails_service.open_blob(tails_reader_handle,
                                                           &rev_reg_def.value.tails_location,
diff --git a/libindy/src/commands/did.rs b/libindy/src/commands/did.rs
@@ -216,7 +216,7 @@ impl DidCommandExecutor {
 
         if let Some(ref did) = my_did_info.did.as_ref() {
             if self.wallet_service.record_exists::<Did>(wallet_handle, did)? {
-                return Err(IndyError::DidError(DidError::AlreadyExistsError(format!("Did already exists"))));
+                return Err(IndyError::DidError(DidError::AlreadyExistsError("Did already exists".to_string())));
             };
         }
 
@@ -558,7 +558,7 @@ impl DidCommandExecutor {
             GetNymReplyResult::GetNymReplyResultV0(res) => {
                 let gen_nym_result_data = GetNymResultDataV0::from_json(&res.data)
                     .map_err(map_err_trace!())
-                    .map_err(|_| CommonError::InvalidState(format!("Invalid GetNymResultData json")))?;
+                    .map_err(|_| CommonError::InvalidState("Invalid GetNymResultData json".to_string()))?;
 
                 TheirDidInfo::new(gen_nym_result_data.dest, gen_nym_result_data.verkey)
             },
diff --git a/libindy/src/commands/ledger.rs b/libindy/src/commands/ledger.rs
@@ -379,7 +379,7 @@ impl LedgerCommandExecutor {
                 request.remove("signature");
                 request.remove("signatures");
                 request
-            }).ok_or(CommonError::InvalidState(format!("Cannot deserialize request")))?;
+            }).ok_or(CommonError::InvalidState("Cannot deserialize request".to_string()))?;
 
         let serialized_request = serialize_signature(message_without_signatures)?;
         let signature = self.crypto_service.sign(&my_key, &serialized_request.as_bytes().to_vec())?;
@@ -839,4 +839,4 @@ impl LedgerCommandExecutor {
 enum SignatureType {
     Single,
     Multi
-}
+}
diff --git a/libindy/src/commands/payments.rs b/libindy/src/commands/payments.rs
@@ -282,7 +282,7 @@ impl PaymentsCommandExecutor {
                 while let Ok(Some(payment_address)) = search.fetch_next_record() {
                     match payment_address.get_value() {
                         Some(value) => list_addresses.push(value.to_string()),
-                        None => cb(Err(IndyError::CommonError(CommonError::InvalidState(format!("Record value not found")))))
+                        None => cb(Err(IndyError::CommonError(CommonError::InvalidState("Record value not found".to_string()))))
                     }
                 }
 
diff --git a/libindy/src/services/anoncreds/issuer.rs b/libindy/src/services/anoncreds/issuer.rs
@@ -108,13 +108,13 @@ impl Issuer {
             if rev_idx.is_some() {
                 let rev_idx = rev_idx.unwrap();
                 let rev_reg = rev_reg
-                    .ok_or(CommonError::InvalidState(format!("RevocationRegistry not found")))?;
+                    .ok_or(CommonError::InvalidState("RevocationRegistry not found".to_string()))?;
                 let rev_key_priv = rev_key_priv
-                    .ok_or(CommonError::InvalidState(format!("RevocationKeyPrivate not found")))?;
+                    .ok_or(CommonError::InvalidState("RevocationKeyPrivate not found".to_string()))?;
                 let rev_reg_def = rev_reg_def
-                    .ok_or(CommonError::InvalidState(format!("RevocationRegistryDefinitionValue not found")))?;
+                    .ok_or(CommonError::InvalidState("RevocationRegistryDefinitionValue not found".to_string()))?;
                 let rev_tails_accessor = rev_tails_accessor
-                    .ok_or(CommonError::InvalidState(format!("RevocationTailsAccessor not found")))?;
+                    .ok_or(CommonError::InvalidState("RevocationTailsAccessor not found".to_string()))?;
 
                 CryptoIssuer::sign_credential_with_revoc(&cred_request.prover_did,
                                                          &cred_request.blinded_ms,
@@ -177,4 +177,4 @@ impl Issuer {
 
         Ok(rev_reg_delta)
     }
-}
+}
diff --git a/libindy/src/services/anoncreds/prover.rs b/libindy/src/services/anoncreds/prover.rs
@@ -183,8 +183,8 @@ impl Prover {
                 .ok_or(CommonError::InvalidStructure(format!("CredentialDefinition not found by id: {:?}", credential.cred_def_id)))?;
 
             let rev_state = if cred_def.value.revocation.is_some() {
-                let timestamp = cred_key.timestamp.clone().ok_or(CommonError::InvalidStructure(format!("Timestamp not found")))?;
-                let rev_reg_id = credential.rev_reg_id.clone().ok_or(CommonError::InvalidStructure(format!("Revocation Registry Id not found")))?;
+                let timestamp = cred_key.timestamp.clone().ok_or(CommonError::InvalidStructure("Timestamp not found".to_string()))?;
+                let rev_reg_id = credential.rev_reg_id.clone().ok_or(CommonError::InvalidStructure("Revocation Registry Id not found".to_string()))?;
                 let rev_states_for_timestamp = rev_states.get(&rev_reg_id)
                     .ok_or(CommonError::InvalidStructure(format!("RevocationState not found by id: {:?}", rev_reg_id)))?;
                 Some(rev_states_for_timestamp.get(&timestamp)
@@ -439,4 +439,4 @@ impl Prover {
 
         Ok(sub_proof_request)
     }
-}
+}
diff --git a/libindy/src/services/anoncreds/verifier.rs b/libindy/src/services/anoncreds/verifier.rs
@@ -40,8 +40,8 @@ impl Verifier {
                 .ok_or(CommonError::InvalidStructure(format!("CredentialDefinition not found for id: {:?}", identifier.cred_def_id)))?;
 
             let (rev_reg_def, rev_reg) = if cred_def.value.revocation.is_some() {
-                let timestamp = identifier.timestamp.clone().ok_or(CommonError::InvalidStructure(format!("Timestamp not found")))?;
-                let rev_reg_id = identifier.rev_reg_id.clone().ok_or(CommonError::InvalidStructure(format!("Revocation Registry Id not found")))?;
+                let timestamp = identifier.timestamp.clone().ok_or(CommonError::InvalidStructure("Timestamp not found".to_string()))?;
+                let rev_reg_id = identifier.rev_reg_id.clone().ok_or(CommonError::InvalidStructure("Revocation Registry Id not found".to_string()))?;
                 let rev_reg_def = Some(rev_reg_defs.get(&rev_reg_id)
                     .ok_or(CommonError::InvalidStructure(format!("RevocationRegistryDefinition not found for id: {:?}", identifier.rev_reg_id)))?);
                 let rev_regs_for_cred = rev_regs.get(&rev_reg_id)
@@ -111,4 +111,4 @@ impl Verifier {
 
         Ok(predicates_for_credential)
     }
-}
+}
diff --git a/libindy/src/services/ledger/mod.rs b/libindy/src/services/ledger/mod.rs
@@ -113,7 +113,7 @@ impl LedgerService {
         info!("build_attrib_request >>> identifier: {:?}, dest: {:?}, hash: {:?}, raw: {:?}, enc: {:?}", identifier, dest, hash, raw, enc);
 
         if raw.is_none() && hash.is_none() && enc.is_none() {
-            return Err(CommonError::InvalidStructure(format!("Either raw or hash or enc must be specified")));
+            return Err(CommonError::InvalidStructure("Either raw or hash or enc must be specified".to_string()));
         }
         if let Some(ref raw) = raw {
             serde_json::from_str::<serde_json::Value>(raw)
@@ -138,7 +138,7 @@ impl LedgerService {
         info!("build_get_attrib_request >>> identifier: {:?}, dest: {:?}, hash: {:?}, raw: {:?}, enc: {:?}", identifier, dest, hash, raw, enc);
 
         if raw.is_none() && hash.is_none() && enc.is_none() {
-            return Err(CommonError::InvalidStructure(format!("Either raw or hash or enc must be specified")));
+            return Err(CommonError::InvalidStructure("Either raw or hash or enc must be specified".to_string()));
         }
         let operation = GetAttribOperation::new(dest.to_string(), raw, hash, enc);
 
diff --git a/libindy/src/services/pool/catchup.rs b/libindy/src/services/pool/catchup.rs
@@ -239,7 +239,7 @@ impl CatchupHandler {
             let index = process.pending_reps.get_min_index()?;
             {
                 let &mut (ref mut first_resp, node_idx) = process.pending_reps.get_mut(index)
-                    .ok_or(CommonError::InvalidStructure(format!("Element not Found")))?;
+                    .ok_or(CommonError::InvalidStructure("Element not Found".to_string()))?;
                 if first_resp.min_tx()? - 1 != process.merkle_tree.count() { break; }
 
                 let mut temp_mt = process.merkle_tree.clone();
diff --git a/libindy/src/services/pool/types.rs b/libindy/src/services/pool/types.rs
@@ -43,10 +43,10 @@ fn string_or_number<'de, D>(deserializer: D) -> Result<Option<u64>, D::Error>
         },
         Ok(serde_json::Value::Number(n)) => match n.as_u64() {
             Some(num) => Ok(Some(num)),
-            None => Err(serde::de::Error::custom(format!("Invalid Node transaction")))
+            None => Err(serde::de::Error::custom("Invalid Node transaction".to_string()))
         },
         Ok(serde_json::Value::Null) => Ok(None),
-        _ => Err(serde::de::Error::custom(format!("Invalid Node transaction"))),
+        _ => Err(serde::de::Error::custom("Invalid Node transaction".to_string())),
     }
 }
 
@@ -246,7 +246,7 @@ impl CatchupRep {
                 Some(m) => if val < m { min = Some(val) }
             }
         }
-        min.ok_or(CommonError::InvalidStructure(format!("Empty Map")))
+        min.ok_or(CommonError::InvalidStructure("Empty Map".to_string()))
     }
 }
 
@@ -498,4 +498,4 @@ pub struct RequestToSend {
 pub struct MessageToProcess {
     pub message: String,
     pub node_idx: usize,
-}
+}
diff --git a/libindy/src/services/wallet/mod.rs b/libindy/src/services/wallet/mod.rs
@@ -246,7 +246,7 @@ impl WalletService {
         let config_json = WalletService::read_config(name)?;
 
         let config = serde_json::from_str::<WalletConfig>(&config_json)
-            .map_err(|err| CommonError::InvalidState(format!("Cannot deserialize Storage Config")))?;
+            .map_err(|err| CommonError::InvalidState("Cannot deserialize Storage Config".to_string()))?;
 
         let credentials = WalletCredentials::from_json(credentials, &config.salt)?;
 
@@ -282,7 +282,7 @@ impl WalletService {
 
         let config_json = WalletService::read_config(name)?;
         let config = serde_json::from_str::<WalletConfig>(&config_json)
-            .map_err(|err| CommonError::InvalidState(format!("Cannot deserialize Storage Config")))?;
+            .map_err(|err| CommonError::InvalidState("Cannot deserialize Storage Config".to_string()))?;
 
         let credentials = WalletCredentials::from_json(credentials, &config.salt)?;
         let storage = storage_type.open_storage(name,
@@ -1587,4 +1587,4 @@ mod tests {
         assert_eq!("type", record.get_type().unwrap());
         assert_eq!("value1", record.get_value().unwrap());
     }
-}
+}
diff --git a/libindy/src/services/wallet/wallet.rs b/libindy/src/services/wallet/wallet.rs
@@ -149,7 +149,7 @@ impl EncryptedValue {
         // value_key is stored as NONCE || CYPHERTEXT. Lenth of CYPHERTHEXT is length of DATA + length of TAG.
         const ENCRYPTED_KEY_LEN: usize = ChaCha20Poly1305IETF::TAGBYTES + ChaCha20Poly1305IETF::NONCEBYTES + ChaCha20Poly1305IETF::KEYBYTES;
         if joined_data.len() < ENCRYPTED_KEY_LEN {
-            return Err(CommonError::InvalidStructure(format!("Unable to split value_key from value: value too short")));
+            return Err(CommonError::InvalidStructure("Unable to split value_key from value: value too short".to_string()));
         }
 
         let value_key = joined_data[..ENCRYPTED_KEY_LEN].to_owned();
diff --git a/libindy/src/utils/crypto/box_/sodium.rs b/libindy/src/utils/crypto/box_/sodium.rs
@@ -26,7 +26,7 @@ pub struct CryptoBox {}
 impl CryptoBox {
     pub fn encrypt(private_key: &[u8], public_key: &[u8], doc: &[u8], nonce: &[u8]) -> Result<Vec<u8>, CommonError> {
         if nonce.len() != 24 {
-            return Err(CommonError::InvalidStructure(format!("Invalid nonce")))
+            return Err(CommonError::InvalidStructure("Invalid nonce".to_string()))
         }
 
         Ok(box_::seal(
@@ -39,7 +39,7 @@ impl CryptoBox {
 
     pub fn decrypt(private_key: &[u8], public_key: &[u8], doc: &[u8], nonce: &[u8]) -> Result<Vec<u8>, CommonError> {
         if nonce.len() != 24 {
-            return Err(CommonError::InvalidStructure(format!("Invalid nonce")))
+            return Err(CommonError::InvalidStructure("Invalid nonce".to_string()))
         }
 
         box_::open(
@@ -57,7 +57,7 @@ impl CryptoBox {
 
     pub fn create_key_pair_for_signature(seed: Option<&[u8]>) -> Result<(Vec<u8>, Vec<u8>), CommonError> {
         if seed.is_some() && seed.unwrap().len() != 32 {
-            return Err(CommonError::InvalidStructure(format!("Invalid seed")));
+            return Err(CommonError::InvalidStructure("Invalid seed".to_string()));
         }
 
         let (public_key, private_key) =
@@ -74,7 +74,7 @@ impl CryptoBox {
 
     pub fn sign(private_key: &[u8], doc: &[u8]) -> Result<Vec<u8>, CommonError> {
         if private_key.len() != 64 {
-            return Err(CommonError::InvalidStructure(format!("Invalid sign key")));
+            return Err(CommonError::InvalidStructure("Invalid sign key".to_string()));
         }
 
         let mut pr_key: [u8; 64] = [0; 64];
@@ -88,11 +88,11 @@ impl CryptoBox {
 
     pub fn verify(public_key: &[u8], doc: &[u8], sign: &[u8]) -> Result<bool, CommonError> {
         if sign.len() != 64 {
-            return Err(CommonError::InvalidStructure(format!("Invalid signature")));
+            return Err(CommonError::InvalidStructure("Invalid signature".to_string()));
         }
 
         if public_key.len() != 32 {
-            return Err(CommonError::InvalidStructure(format!("Invalid verkey")));
+            return Err(CommonError::InvalidStructure("Invalid verkey".to_string()));
         }
 
         let mut signature: [u8; 64] = [0; 64];
@@ -107,7 +107,7 @@ impl CryptoBox {
 
     pub fn sk_to_curve25519(sk: &[u8]) -> Result<Vec<u8>, CommonError> {
         if sk.len() != 64 {
-            return Err(CommonError::InvalidStructure(format!("Invalid signkey")));
+            return Err(CommonError::InvalidStructure("Invalid signkey".to_string()));
         }
 
         let mut from: [u8; 64] = [0; 64];
@@ -121,7 +121,7 @@ impl CryptoBox {
 
     pub fn vk_to_curve25519(pk: &[u8]) -> Result<Vec<u8>, CommonError> {
         if pk.len() != 32 {
-            return Err(CommonError::InvalidStructure(format!("Invalid verkey")));
+            return Err(CommonError::InvalidStructure("Invalid verkey".to_string()));
         }
 
         let mut from: [u8; 32] = [0; 32];
@@ -191,4 +191,4 @@ mod tests {
         let skc_exp = vec!(144, 112, 64, 101, 69, 167, 61, 44, 220, 148, 58, 187, 108, 73, 11, 247, 130, 161, 158, 40, 100, 1, 40, 27, 76, 148, 209, 240, 195, 35, 153, 121);
         assert_eq!(skc_exp, skc_test);
     }
-}
+}

Original file line number	Diff line number	Diff line change
`@@ -282,7 +282,7 @@ impl PaymentsCommandExecutor {`
`282`	`282`	`while let Ok(Some(payment_address)) = search.fetch_next_record() {`
`283`	`283`	`match payment_address.get_value() {`
`284`	`284`	`Some(value) => list_addresses.push(value.to_string()),`
`285`		`- None => cb(Err(IndyError::CommonError(CommonError::InvalidState(format!("Record value not found")))))`
	`285`	`+ None => cb(Err(IndyError::CommonError(CommonError::InvalidState("Record value not found".to_string()))))`
`286`	`286`	`}`
`287`	`287`	`}`
`288`	`288`
Original file line number	Diff line number	Diff line change
`@@ -113,7 +113,7 @@ impl LedgerService {`
`113`	`113`	`info!("build_attrib_request >>> identifier: {:?}, dest: {:?}, hash: {:?}, raw: {:?}, enc: {:?}", identifier, dest, hash, raw, enc);`
`114`	`114`
`115`	`115`	`if raw.is_none() && hash.is_none() && enc.is_none() {`
`116`		`- return Err(CommonError::InvalidStructure(format!("Either raw or hash or enc must be specified")));`
	`116`	`+ return Err(CommonError::InvalidStructure("Either raw or hash or enc must be specified".to_string()));`
`117`	`117`	`}`
`118`	`118`	`if let Some(ref raw) = raw {`
`119`	`119`	`serde_json::from_str::<serde_json::Value>(raw)`
`@@ -138,7 +138,7 @@ impl LedgerService {`
`138`	`138`	`info!("build_get_attrib_request >>> identifier: {:?}, dest: {:?}, hash: {:?}, raw: {:?}, enc: {:?}", identifier, dest, hash, raw, enc);`
`139`	`139`
`140`	`140`	`if raw.is_none() && hash.is_none() && enc.is_none() {`
`141`		`- return Err(CommonError::InvalidStructure(format!("Either raw or hash or enc must be specified")));`
	`141`	`+ return Err(CommonError::InvalidStructure("Either raw or hash or enc must be specified".to_string()));`
`142`	`142`	`}`
`143`	`143`	`let operation = GetAttribOperation::new(dest.to_string(), raw, hash, enc);`
`144`	`144`
Original file line number	Diff line number	Diff line change
`@@ -239,7 +239,7 @@ impl CatchupHandler {`
`239`	`239`	`let index = process.pending_reps.get_min_index()?;`
`240`	`240`	`{`
`241`	`241`	`let &mut (ref mut first_resp, node_idx) = process.pending_reps.get_mut(index)`
`242`		`- .ok_or(CommonError::InvalidStructure(format!("Element not Found")))?;`
	`242`	`+ .ok_or(CommonError::InvalidStructure("Element not Found".to_string()))?;`
`243`	`243`	`if first_resp.min_tx()? - 1 != process.merkle_tree.count() { break; }`
`244`	`244`
`245`	`245`	`let mut temp_mt = process.merkle_tree.clone();`