clippy: clean up match and "if let"
diff --git a/src/client.rs b/src/client.rs
index d804b98..b9933c0 100644
--- a/src/client.rs
+++ b/src/client.rs
@@ -479,9 +479,8 @@
}
};
- match targets.targets().get(target) {
- Some(t) => return (default_terminate, Ok(t.clone())),
- None => (),
+ if let Some(t) = targets.targets().get(target) {
+ return (default_terminate, Ok(t.clone()));
}
let delegations = match targets.delegations() {
diff --git a/src/crypto.rs b/src/crypto.rs
index 25618ad..7227abf 100644
--- a/src/crypto.rs
+++ b/src/crypto.rs
@@ -74,10 +74,10 @@
let mut size = 0;
let mut hashes = HashMap::new();
for alg in hash_algs {
- let context = match alg {
- &HashAlgorithm::Sha256 => digest::Context::new(&SHA256),
- &HashAlgorithm::Sha512 => digest::Context::new(&SHA512),
- &HashAlgorithm::Unknown(ref s) => return Err(Error::IllegalArgument(
+ let context = match *alg {
+ HashAlgorithm::Sha256 => digest::Context::new(&SHA256),
+ HashAlgorithm::Sha512 => digest::Context::new(&SHA512),
+ HashAlgorithm::Unknown(ref s) => return Err(Error::IllegalArgument(
format!("Unknown hash algorithm: {}", s)
)),
};
@@ -278,10 +278,10 @@
}
fn as_oid(&self) -> Result<&'static [u8]> {
- match self {
- &KeyType::Rsa => Ok(RSA_SPKI_OID),
- &KeyType::Ed25519 => Ok(ED25519_SPKI_OID),
- &KeyType::Unknown(ref s) => Err(Error::UnknownKeyType(s.clone())),
+ match *self {
+ KeyType::Rsa => Ok(RSA_SPKI_OID),
+ KeyType::Ed25519 => Ok(ED25519_SPKI_OID),
+ KeyType::Unknown(ref s) => Err(Error::UnknownKeyType(s.clone())),
}
}
}
@@ -300,10 +300,10 @@
impl ToString for KeyType {
fn to_string(&self) -> String {
- match self {
- &KeyType::Ed25519 => "ed25519".to_string(),
- &KeyType::Rsa => "rsa".to_string(),
- &KeyType::Unknown(ref s) => s.to_string(),
+ match *self {
+ KeyType::Ed25519 => "ed25519".to_string(),
+ KeyType::Rsa => "rsa".to_string(),
+ KeyType::Unknown(ref s) => s.to_string(),
}
}
}
@@ -333,9 +333,9 @@
impl Debug for PrivateKeyType {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- let s = match self {
- &PrivateKeyType::Ed25519(_) => "ed25519",
- &PrivateKeyType::Rsa(_) => "rsa",
+ let s = match *self {
+ PrivateKeyType::Ed25519(_) => "ed25519",
+ PrivateKeyType::Rsa(_) => "rsa",
};
write!(f, "PrivateKeyType {{ \"{}\" }}", s)
}
@@ -451,13 +451,10 @@
}
fn rsa_from_pkcs8(der_key: &[u8], scheme: SignatureScheme) -> Result<Self> {
- match &scheme {
- &SignatureScheme::Ed25519 => {
- return Err(Error::IllegalArgument(
- "RSA keys do not support the Ed25519 signing scheme".into(),
- ))
- }
- _ => (),
+ if let SignatureScheme::Ed25519 = scheme {
+ return Err(Error::IllegalArgument(
+ "RSA keys do not support the Ed25519 signing scheme".into(),
+ ));
}
let key = RSAKeyPair::from_pkcs8(Input::from(der_key)).map_err(|_| {
@@ -648,11 +645,11 @@
/// Use this key to verify a message with a signature.
pub fn verify(&self, msg: &[u8], sig: &Signature) -> Result<()> {
- let alg: &ring::signature::VerificationAlgorithm = match &self.scheme {
- &SignatureScheme::Ed25519 => &ED25519,
- &SignatureScheme::RsaSsaPssSha256 => &RSA_PSS_2048_8192_SHA256,
- &SignatureScheme::RsaSsaPssSha512 => &RSA_PSS_2048_8192_SHA512,
- &SignatureScheme::Unknown(ref s) => return Err(Error::IllegalArgument(
+ let alg: &ring::signature::VerificationAlgorithm = match self.scheme {
+ SignatureScheme::Ed25519 => &ED25519,
+ SignatureScheme::RsaSsaPssSha256 => &RSA_PSS_2048_8192_SHA256,
+ SignatureScheme::RsaSsaPssSha512 => &RSA_PSS_2048_8192_SHA512,
+ SignatureScheme::Unknown(ref s) => return Err(Error::IllegalArgument(
format!("Unknown signature scheme: {}", s)
)),
};
diff --git a/src/interchange/cjson.rs b/src/interchange/cjson.rs
index 2071fb6..5f2d947 100644
--- a/src/interchange/cjson.rs
+++ b/src/interchange/cjson.rs
@@ -20,27 +20,37 @@
impl Value {
fn write(&self, mut buf: &mut Vec<u8>) -> Result<(), String> {
- match self {
- &Value::Null => Ok(buf.extend(b"null")),
- &Value::Bool(true) => Ok(buf.extend(b"true")),
- &Value::Bool(false) => Ok(buf.extend(b"false")),
- &Value::Number(Number::I64(n)) => {
+ match *self {
+ Value::Null => {
+ buf.extend(b"null");
+ Ok(())
+ }
+ Value::Bool(true) => {
+ buf.extend(b"true");
+ Ok(())
+ }
+ Value::Bool(false) => {
+ buf.extend(b"false");
+ Ok(())
+ }
+ Value::Number(Number::I64(n)) => {
itoa::write(buf, n).map(|_| ()).map_err(|err| {
format!("Write error: {}", err)
})
}
- &Value::Number(Number::U64(n)) => {
+ Value::Number(Number::U64(n)) => {
itoa::write(buf, n).map(|_| ()).map_err(|err| {
format!("Write error: {}", err)
})
}
- &Value::String(ref s) => {
+ Value::String(ref s) => {
// this mess is abusing serde_json to get json escaping
let s = json::Value::String(s.clone());
let s = json::to_string(&s).map_err(|e| format!("{:?}", e))?;
- Ok(buf.extend(s.as_bytes()))
+ buf.extend(s.as_bytes());
+ Ok(())
}
- &Value::Array(ref arr) => {
+ Value::Array(ref arr) => {
buf.push(b'[');
let mut first = true;
for a in arr.iter() {
@@ -50,9 +60,10 @@
a.write(&mut buf)?;
first = false;
}
- Ok(buf.push(b']'))
+ buf.push(b']');
+ Ok(())
}
- &Value::Object(ref obj) => {
+ Value::Object(ref obj) => {
buf.push(b'{');
let mut first = true;
for (k, v) in obj.iter() {
@@ -69,7 +80,8 @@
buf.push(b':');
v.write(&mut buf)?;
}
- Ok(buf.push(b'}'))
+ buf.push(b'}');
+ Ok(())
}
}
}
@@ -81,31 +93,31 @@
}
fn convert(jsn: &json::Value) -> Result<Value, String> {
- match jsn {
- &json::Value::Null => Ok(Value::Null),
- &json::Value::Bool(b) => Ok(Value::Bool(b)),
- &json::Value::Number(ref n) => {
+ match *jsn {
+ json::Value::Null => Ok(Value::Null),
+ json::Value::Bool(b) => Ok(Value::Bool(b)),
+ json::Value::Number(ref n) => {
n.as_i64()
.map(Number::I64)
- .or(n.as_u64().map(Number::U64))
+ .or_else(|| n.as_u64().map(Number::U64))
.map(Value::Number)
.ok_or_else(|| String::from("only i64 and u64 are supported"))
}
- &json::Value::Array(ref arr) => {
+ json::Value::Array(ref arr) => {
let mut out = Vec::new();
for res in arr.iter().map(|v| convert(v)) {
out.push(res?)
}
Ok(Value::Array(out))
}
- &json::Value::Object(ref obj) => {
+ json::Value::Object(ref obj) => {
let mut out = BTreeMap::new();
for (k, v) in obj.iter() {
let _ = out.insert(k.clone(), convert(v)?);
}
Ok(Value::Object(out))
}
- &json::Value::String(ref s) => Ok(Value::String(s.clone())),
+ json::Value::String(ref s) => Ok(Value::String(s.clone())),
}
}
diff --git a/src/metadata.rs b/src/metadata.rs
index 9b77bac..90a1c36 100644
--- a/src/metadata.rs
+++ b/src/metadata.rs
@@ -168,12 +168,12 @@
/// assert!(!Role::Root.fuzzy_matches_path(&MetadataPath::new("wat".into()).unwrap()));
/// ```
pub fn fuzzy_matches_path(&self, path: &MetadataPath) -> bool {
- match self {
- &Role::Root if &path.0 == "root" => true,
- &Role::Snapshot if &path.0 == "snapshot" => true,
- &Role::Timestamp if &path.0 == "timestamp" => true,
- &Role::Targets if &path.0 == "targets" => true,
- &Role::Targets if !&["root", "snapshot", "targets"].contains(&path.0.as_str()) => true,
+ match *self {
+ Role::Root if &path.0 == "root" => true,
+ Role::Snapshot if &path.0 == "snapshot" => true,
+ Role::Timestamp if &path.0 == "timestamp" => true,
+ Role::Targets if &path.0 == "targets" => true,
+ Role::Targets if !&["root", "snapshot", "targets"].contains(&path.0.as_str()) => true,
_ => false,
}
}
@@ -181,11 +181,11 @@
impl Display for Role {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- match self {
- &Role::Root => write!(f, "root"),
- &Role::Snapshot => write!(f, "snapshot"),
- &Role::Targets => write!(f, "targets"),
- &Role::Timestamp => write!(f, "timestamp"),
+ match *self {
+ Role::Root => write!(f, "root"),
+ Role::Snapshot => write!(f, "snapshot"),
+ Role::Targets => write!(f, "targets"),
+ Role::Timestamp => write!(f, "timestamp"),
}
}
}
@@ -204,10 +204,10 @@
impl MetadataVersion {
/// Converts this struct into the string used for addressing metadata.
pub fn prefix(&self) -> String {
- match self {
- &MetadataVersion::None => String::new(),
- &MetadataVersion::Number(ref x) => format!("{}.", x),
- &MetadataVersion::Hash(ref v) => format!("{}.", v),
+ match *self {
+ MetadataVersion::None => String::new(),
+ MetadataVersion::Number(ref x) => format!("{}.", x),
+ MetadataVersion::Hash(ref v) => format!("{}.", v),
}
}
}
diff --git a/src/repository.rs b/src/repository.rs
index 410d45c..e0d36a8 100644
--- a/src/repository.rs
+++ b/src/repository.rs
@@ -302,7 +302,7 @@
let mut segments = url.path_segments_mut().map_err(|_| {
Error::IllegalArgument(format!("URL was 'cannot-be-a-base': {:?}", self.url))
})?;
- if let &Some(ref prefix) = prefix {
+ if let Some(ref prefix) = prefix {
segments.extend(prefix);
}
segments.extend(components);
diff --git a/src/tuf.rs b/src/tuf.rs
index 56dda7b..777ed5d 100644
--- a/src/tuf.rs
+++ b/src/tuf.rs
@@ -535,37 +535,37 @@
}
fn safe_snapshot_ref(&self) -> Result<&SnapshotMetadata> {
- match &self.snapshot {
- &Some(ref snapshot) => {
+ match self.snapshot {
+ Some(ref snapshot) => {
if snapshot.expires() <= &Utc::now() {
return Err(Error::ExpiredMetadata(Role::Snapshot));
}
Ok(snapshot)
}
- &None => Err(Error::MissingMetadata(Role::Snapshot)),
+ None => Err(Error::MissingMetadata(Role::Snapshot)),
}
}
fn safe_targets_ref(&self) -> Result<&TargetsMetadata> {
- match &self.targets {
- &Some(ref targets) => {
+ match self.targets {
+ Some(ref targets) => {
if targets.expires() <= &Utc::now() {
return Err(Error::ExpiredMetadata(Role::Targets));
}
Ok(targets)
}
- &None => Err(Error::MissingMetadata(Role::Targets)),
+ None => Err(Error::MissingMetadata(Role::Targets)),
}
}
fn safe_timestamp_ref(&self) -> Result<&TimestampMetadata> {
- match &self.timestamp {
- &Some(ref timestamp) => {
+ match self.timestamp {
+ Some(ref timestamp) => {
if timestamp.expires() <= &Utc::now() {
return Err(Error::ExpiredMetadata(Role::Timestamp));
}
Ok(timestamp)
}
- &None => Err(Error::MissingMetadata(Role::Timestamp)),
+ None => Err(Error::MissingMetadata(Role::Timestamp)),
}
}
}
diff --git a/src/util.rs b/src/util.rs
index 0845e8e..ea0f5b2 100644
--- a/src/util.rs
+++ b/src/util.rs
@@ -41,10 +41,10 @@
) -> Result<Self> {
let hasher = match hash_data {
Some((alg, value)) => {
- let ctx = match alg {
- &HashAlgorithm::Sha256 => digest::Context::new(&SHA256),
- &HashAlgorithm::Sha512 => digest::Context::new(&SHA512),
- &HashAlgorithm::Unknown(ref s) => return Err(Error::IllegalArgument(
+ let ctx = match *alg {
+ HashAlgorithm::Sha256 => digest::Context::new(&SHA256),
+ HashAlgorithm::Sha512 => digest::Context::new(&SHA512),
+ HashAlgorithm::Unknown(ref s) => return Err(Error::IllegalArgument(
format!("Unknown hash algorithm: {}", s)
)),
};
@@ -109,9 +109,8 @@
}
}
- match self.hasher {
- Some((ref mut context, _)) => context.update(&buf[..(read_bytes)]),
- None => (),
+ if let Some((ref mut context, _)) = self.hasher {
+ context.update(&buf[..(read_bytes)]);
}
Ok(read_bytes)
