chore: Enable and fix Clippy lints

Author: Kriskras99

Cargo.toml

@@ -58,14 +58,13 @@ clippy.too_long_first_doc_paragraph = "warn"
 clippy.doc_markdown = "warn"
 # TODO: Needs more work
 #clippy.missing_errors_doc = "warn"
-#clippy.missing_panics_doc = "warn"
+clippy.missing_panics_doc = "warn"
 rust.unexpected_cfgs = { level = "warn", check-cfg = ['cfg(nightly)'] }
 clippy.cargo = { level = "warn", priority = -1 }
 clippy.multiple_crate_versions = "allow"
-# clippy.needless_raw_string_hashes = "warn"
-# clippy.missing_panics_doc = "warn"
-# clippy.semicolon_if_nothing_returned = "warn"
-# clippy.manual_assert = "warn"
-# clippy.enum_glob_use = "warn"
-# clippy.needless_pass_by_value = "warn"
-# clippy.single_match_else = "warn"
+clippy.needless_raw_string_hashes = "warn"
+clippy.semicolon_if_nothing_returned = "warn"
+clippy.manual_assert = "warn"
+clippy.enum_glob_use = "warn"
+clippy.needless_pass_by_value = "warn"
+clippy.single_match_else = "warn"

avro/benches/serde.rs

@@ -360,7 +360,7 @@ fn bench_small_schema_write_10_000_record_ser(c: &mut Criterion) {
         10_000,
         "small schema, write 10k records (serde way)",
     )
-    .unwrap()
+    .unwrap();
 }
 
 fn bench_small_schema_read_1_record(c: &mut Criterion) {

avro/benches/single.rs

@@ -180,7 +180,7 @@ fn bench_small_schema_write_record(c: &mut Criterion) {
                 .build()
                 .unwrap()
                 .write_value_to_vec(record.clone())
-        })
+        });
     });
 }
 
@@ -192,23 +192,23 @@ fn bench_big_schema_write_record(c: &mut Criterion) {
                 .build()
                 .unwrap()
                 .write_value_to_vec(record.clone())
-        })
+        });
     });
 }
 
 fn bench_small_schema_write_record_reuse_datum_writer(c: &mut Criterion) {
     let (schema, record) = make_small_record().unwrap();
     let writer = GenericDatumWriter::builder(&schema).build().unwrap();
     c.bench_function("small record (reused writer)", |b| {
-        b.iter(|| writer.write_value_ref(&mut Vec::new(), &record))
+        b.iter(|| writer.write_value_ref(&mut Vec::new(), &record));
     });
 }
 
 fn bench_big_schema_write_record_reuse_datum_writer(c: &mut Criterion) {
     let (schema, record) = make_big_record().unwrap();
     let writer = GenericDatumWriter::builder(&schema).build().unwrap();
     c.bench_function("big record (reused writer)", |b| {
-        b.iter(|| writer.write_value_ref(&mut Vec::new(), &record))
+        b.iter(|| writer.write_value_ref(&mut Vec::new(), &record));
     });
 }
 
@@ -219,7 +219,7 @@ fn bench_small_schema_write_record_no_validation(c: &mut Criterion) {
         .build()
         .unwrap();
     c.bench_function("small record (no validation)", |b| {
-        b.iter(|| writer.write_value_ref(&mut Vec::new(), &record))
+        b.iter(|| writer.write_value_ref(&mut Vec::new(), &record));
     });
 }
 
@@ -230,7 +230,7 @@ fn bench_big_schema_write_record_no_validation(c: &mut Criterion) {
         .build()
         .unwrap();
     c.bench_function("big record (no validation)", |b| {
-        b.iter(|| writer.write_value_ref(&mut Vec::new(), &record))
+        b.iter(|| writer.write_value_ref(&mut Vec::new(), &record));
     });
 }
 

avro/examples/test_interop_single_object_encoding.rs

@@ -58,7 +58,7 @@ fn main() -> Result<(), Box<dyn Error>> {
     let single_object = std::fs::read(format!("{resource_folder}/test_message.bin"))
         .expect("File with single object not found or error occurred while reading it.");
     test_write(&single_object);
-    test_read(single_object);
+    test_read(&single_object);
 
     Ok(())
 }
@@ -69,17 +69,16 @@ fn test_write(expected: &[u8]) {
         .expect("Resolving failed")
         .write_value(InteropMessage, &mut encoded)
         .expect("Encoding failed");
-    assert_eq!(expected, &encoded)
+    assert_eq!(expected, &encoded);
 }
 
-fn test_read(encoded: Vec<u8>) {
-    let mut encoded = &encoded[..];
+fn test_read(mut encoded: &[u8]) {
     let read_message = apache_avro::GenericSingleObjectReader::builder()
         .schema(InteropMessage::get_schema())
         .build()
         .expect("Resolving failed")
         .read_value(&mut encoded)
         .expect("Decoding failed");
     let expected_value: Value = InteropMessage.into();
-    assert_eq!(expected_value, read_message)
+    assert_eq!(expected_value, read_message);
 }

avro/src/codec.rs

@@ -108,10 +108,10 @@ impl Codec {
             #[cfg(feature = "zstandard")]
             Codec::Zstandard(settings) => {
                 use std::io::Write;
-                let mut encoder =
-                    zstd::Encoder::new(Vec::new(), settings.compression_level as i32).unwrap();
+                let mut encoder = zstd::Encoder::new(Vec::new(), settings.compression_level as i32)
+                    .map_err(Details::ZstdCompress)?;
                 encoder.write_all(stream).map_err(Details::ZstdCompress)?;
-                *stream = encoder.finish().unwrap();
+                *stream = encoder.finish().map_err(Details::ZstdCompress)?;
             }
             #[cfg(feature = "bzip")]
             Codec::Bzip2(settings) => {
@@ -120,7 +120,9 @@ impl Codec {
 
                 let mut encoder = BzEncoder::new(&stream[..], settings.compression());
                 let mut buffer = Vec::new();
-                encoder.read_to_end(&mut buffer).unwrap();
+                encoder
+                    .read_to_end(&mut buffer)
+                    .unwrap_or_else(|_| unreachable!("No I/O errors possible with Vec<u8>"));
                 *stream = buffer;
             }
             #[cfg(feature = "xz")]
@@ -130,7 +132,9 @@ impl Codec {
 
                 let mut encoder = XzEncoder::new(&stream[..], settings.compression_level as u32);
                 let mut buffer = Vec::new();
-                encoder.read_to_end(&mut buffer).unwrap();
+                encoder
+                    .read_to_end(&mut buffer)
+                    .unwrap_or_else(|_| unreachable!("No I/O errors possible with Vec<u8>"));
                 *stream = buffer;
             }
         };
@@ -144,7 +148,7 @@ impl Codec {
             Codec::Null => return Ok(()),
             Codec::Deflate(_settings) => miniz_oxide::inflate::decompress_to_vec(stream).map_err(|e| {
                 let err = {
-                    use miniz_oxide::inflate::TINFLStatus::*;
+                    use miniz_oxide::inflate::TINFLStatus::{FailedCannotMakeProgress, BadParam, Adler32Mismatch, Failed, Done, NeedsMoreInput, HasMoreOutput};
                     use std::io::{Error,ErrorKind};
                     match e.status {
                         FailedCannotMakeProgress => Error::from(ErrorKind::UnexpectedEof),
@@ -189,7 +193,7 @@ impl Codec {
                 let mut decoded = Vec::new();
                 let buffer_size = zstd_safe::DCtx::in_size();
                 let buffer = BufReader::with_capacity(buffer_size, &stream[..]);
-                let mut decoder = zstd::Decoder::new(buffer).unwrap();
+                let mut decoder = zstd::Decoder::new(buffer).map_err(Details::ZstdDecompress)?;
                 std::io::copy(&mut decoder, &mut decoded).map_err(Details::ZstdDecompress)?;
                 decoded
             }
@@ -200,7 +204,7 @@ impl Codec {
 
                 let mut decoder = BzDecoder::new(&stream[..]);
                 let mut decoded = Vec::new();
-                decoder.read_to_end(&mut decoded).unwrap();
+                decoder.read_to_end(&mut decoded).unwrap_or_else(|_| unreachable!("No I/O errors possible with Vec<u8>"));
                 decoded
             }
             #[cfg(feature = "xz")]
@@ -210,7 +214,7 @@ impl Codec {
 
                 let mut decoder = XzDecoder::new(&stream[..]);
                 let mut decoded: Vec<u8> = Vec::new();
-                decoder.read_to_end(&mut decoded).unwrap();
+                decoder.read_to_end(&mut decoded).unwrap_or_else(|_| unreachable!("No I/O errors possible with Vec<u8>"));
                 decoded
             }
         };

avro/src/rabin.rs

@@ -103,7 +103,7 @@ impl Update for Rabin {
 
 impl FixedOutput for Rabin {
     fn finalize_into(self, out: &mut Output<Self>) {
-        out.copy_from_slice(&self.result.to_le_bytes())
+        out.copy_from_slice(&self.result.to_le_bytes());
     }
 }
 

avro/src/reader/mod.rs

@@ -184,6 +184,9 @@ impl<R: Read, T: DeserializeOwned> Iterator for ReaderDeser<'_, R, T> {
 }
 
 /// Reads the marker bytes from Avro bytes generated earlier by a `Writer`
+///
+/// # Panics
+/// Will panic if `bytes` does not contain at least 16 bytes.
 pub fn read_marker(bytes: &[u8]) -> [u8; 16] {
     assert!(
         bytes.len() > 16,

avro/src/schema/mod.rs

@@ -464,8 +464,9 @@ impl Schema {
     /// [Parsing Canonical Form]:
     /// https://avro.apache.org/docs/++version++/specification/#parsing-canonical-form-for-schemas
     pub fn canonical_form(&self) -> String {
-        let json = serde_json::to_value(self)
-            .unwrap_or_else(|e| panic!("Cannot parse Schema from JSON: {e}"));
+        let json = serde_json::to_value(self).unwrap_or_else(|e| {
+            unreachable!("Cannot parse Schema from JSON that was just generated: {e}")
+        });
         let mut defined_names = HashSet::new();
         parsing_canonical_form(&json, &mut defined_names)
     }

avro/src/schema/parser.rs

@@ -96,7 +96,7 @@ impl Parser {
                 .expect("Key unexpectedly missing");
             let parsed = self.parse(&value, None)?;
             self.parsed_schemas
-                .insert(self.get_schema_type_name(name, value), parsed);
+                .insert(self.get_schema_type_name(name, &value), parsed);
         }
         Ok(())
     }
@@ -197,7 +197,7 @@ impl Parser {
         // parsing a full schema from inside another schema. Other full schema will not inherit namespace
         let parsed = self.parse(&value, None)?;
         self.parsed_schemas.insert(
-            self.get_schema_type_name(fully_qualified_name, value),
+            self.get_schema_type_name(fully_qualified_name, &value),
             parsed.clone(),
         );
 
@@ -583,7 +583,7 @@ impl Parser {
             doc: complex.doc(),
             fields,
             lookup,
-            attributes: self.get_custom_attributes(complex, vec!["fields"]),
+            attributes: self.get_custom_attributes(complex, &["fields"]),
         });
 
         self.register_parsed_schema(&fully_qualified_name, &schema, &aliases);
@@ -593,7 +593,7 @@ impl Parser {
     fn get_custom_attributes(
         &self,
         complex: &Map<String, Value>,
-        excluded: Vec<&'static str>,
+        excluded: &[&'static str],
     ) -> BTreeMap<String, Value> {
         let mut custom_attributes: BTreeMap<String, Value> = BTreeMap::new();
         for (key, value) in complex {
@@ -675,7 +675,7 @@ impl Parser {
             doc: complex.doc(),
             symbols,
             default,
-            attributes: self.get_custom_attributes(complex, vec!["symbols", "default"]),
+            attributes: self.get_custom_attributes(complex, &["symbols", "default"]),
         });
 
         self.register_parsed_schema(&fully_qualified_name, &schema, &aliases);
@@ -695,7 +695,7 @@ impl Parser {
             .and_then(|items| self.parse(items, enclosing_namespace))?;
         Ok(Schema::Array(ArraySchema {
             items: Box::new(items),
-            attributes: self.get_custom_attributes(complex, vec!["items"]),
+            attributes: self.get_custom_attributes(complex, &["items"]),
         }))
     }
 
@@ -712,7 +712,7 @@ impl Parser {
 
         Ok(Schema::Map(MapSchema {
             types: Box::new(types),
-            attributes: self.get_custom_attributes(complex, vec!["values"]),
+            attributes: self.get_custom_attributes(complex, &["values"]),
         }))
     }
 
@@ -778,7 +778,7 @@ impl Parser {
             aliases: aliases.clone(),
             doc,
             size: size as usize,
-            attributes: self.get_custom_attributes(complex, vec!["size"]),
+            attributes: self.get_custom_attributes(complex, &["size"]),
         });
 
         self.register_parsed_schema(&fully_qualified_name, &schema, &aliases);
@@ -814,7 +814,7 @@ impl Parser {
         })
     }
 
-    fn get_schema_type_name(&self, name: Name, value: Value) -> Name {
+    fn get_schema_type_name(&self, name: Name, value: &Value) -> Name {
         match value.get("type") {
             Some(Value::Object(complex_type)) => match complex_type.name() {
                 Some(name) => Name::new(name).unwrap(),

avro/src/schema/record/field.rs

@@ -141,45 +141,42 @@ impl RecordField {
     ) -> AvroResult<()> {
         if let Some(value) = default {
             let avro_value = types::Value::try_from(value.clone())?;
-            match field_schema {
-                Schema::Union(union_schema) => {
-                    let schemas = &union_schema.schemas;
-                    let resolved = schemas.iter().any(|schema| {
-                        avro_value
-                            .to_owned()
-                            .resolve_internal(schema, names, schema.namespace(), &None)
-                            .is_ok()
-                    });
+            if let Schema::Union(union_schema) = field_schema {
+                let schemas = &union_schema.schemas;
+                let resolved = schemas.iter().any(|schema| {
+                    avro_value
+                        .to_owned()
+                        .resolve_internal(schema, names, schema.namespace(), &None)
+                        .is_ok()
+                });
 
-                    if !resolved {
-                        let schema: Option<&Schema> = schemas.first();
-                        return match schema {
-                            Some(first_schema) => Err(Details::GetDefaultUnion(
-                                SchemaKind::from(first_schema),
-                                types::ValueKind::from(avro_value),
-                            )
-                            .into()),
-                            None => Err(Details::EmptyUnion.into()),
-                        };
-                    }
+                if !resolved {
+                    let schema: Option<&Schema> = schemas.first();
+                    return match schema {
+                        Some(first_schema) => Err(Details::GetDefaultUnion(
+                            SchemaKind::from(first_schema),
+                            types::ValueKind::from(avro_value),
+                        )
+                        .into()),
+                        None => Err(Details::EmptyUnion.into()),
+                    };
                 }
-                _ => {
-                    let resolved = avro_value
-                        .resolve_internal(field_schema, names, field_schema.namespace(), &None)
-                        .is_ok();
+            } else {
+                let resolved = avro_value
+                    .resolve_internal(field_schema, names, field_schema.namespace(), &None)
+                    .is_ok();
 
-                    if !resolved {
-                        let schemata = names.values().cloned().collect::<Vec<_>>();
-                        return Err(Details::GetDefaultRecordField(
-                            field_name.to_string(),
-                            record_name.to_string(),
-                            field_schema
-                                .independent_canonical_form(&schemata)
-                                .unwrap_or_else(|_| field_schema.canonical_form()),
-                            value.clone(),
-                        )
-                        .into());
-                    }
+                if !resolved {
+                    let schemata = names.values().cloned().collect::<Vec<_>>();
+                    return Err(Details::GetDefaultRecordField(
+                        field_name.to_string(),
+                        record_name.to_string(),
+                        field_schema
+                            .independent_canonical_form(&schemata)
+                            .unwrap_or_else(|_| field_schema.canonical_form()),
+                        value.clone(),
+                    )
+                    .into());
                 }
             };
         }