code style refactor

granc-test-support/src/compiler.rs

@@ -8,27 +8,28 @@ use std::fs;
 /// * `files` - A list of tuples (filename, content). E.g. `[("test.proto", "syntax=...")]`
 pub fn compile_protos(files: &[(&str, &str)]) -> FileDescriptorSet {
     let temp_dir = tempfile::tempdir().expect("Failed to create temp dir");
+    let descriptor_path = temp_dir.path().join("descriptor.bin");
     let proto_dir = temp_dir.path().join("protos");
+
     fs::create_dir(&proto_dir).expect("Failed to create protos dir");
 
-    let mut proto_paths = Vec::new();
-    for (name, content) in files {
-        let path = proto_dir.join(name);
-        fs::write(&path, content).expect("Failed to write proto file");
-        proto_paths.push(path);
-    }
+    let paths: Vec<_> = files
+        .into_iter()
+        .map(|(name, content)| {
+            let path = proto_dir.join(name);
+            fs::write(&path, content).expect("Failed to write proto file");
+            path
+        })
+        .collect();
 
-    let descriptor_path = temp_dir.path().join("descriptor.bin");
-
-    // Compile using prost_build
     let mut config = prost_build::Config::new();
     config.file_descriptor_set_path(&descriptor_path);
     config.out_dir(temp_dir.path());
-
     config
-        .compile_protos(&proto_paths, &[proto_dir])
+        .compile_protos(&paths, &[proto_dir])
         .expect("Failed to compile protos");
 
     let bytes = fs::read(descriptor_path).expect("Failed to read descriptor set");
+
     FileDescriptorSet::decode(bytes.as_slice()).expect("Failed to decode File descriptor set")
 }

granc/src/docgen/package.rs

@@ -4,6 +4,9 @@ use granc_core::{
 };
 use std::collections::{HashMap, hash_map::Keys};
 
+/// Represents a single protobuffer package.
+///
+/// It contains all the services, messages and enums described in the package.
 pub(crate) struct Package {
     pub name: String,
     pub services: Vec<ServiceDescriptor>,
@@ -39,6 +42,7 @@ impl From<Descriptor> for Package {
     }
 }
 
+/// Represents a collection of protobuffer packages, each containing the corresponding file descriptors
 pub(crate) struct Packages(HashMap<String, Package>);
 
 impl Packages {
@@ -53,49 +57,54 @@ impl Packages {
 
 impl From<ServiceDescriptor> for Packages {
     fn from(value: ServiceDescriptor) -> Self {
-        // Collect all reachable descriptors (Messages, Enums) from the Service methods
-        let mut descriptors: HashMap<String, Descriptor> = value
-            .methods()
-            .flat_map(|m| [m.input(), m.output()])
-            .fold(HashMap::new(), |mut acc, d| {
-                let message_name = d.full_name().to_string();
+        let mut descriptors = collect_service_dependencies(&value);
 
-                if acc.contains_key(&message_name) {
-                    return acc;
-                }
-
-                acc.insert(message_name, Descriptor::MessageDescriptor(d.clone()));
-
-                collect_message_dependencies(acc, &d)
-            });
-
-        // Insert the Service itself
         descriptors.insert(
             value.full_name().to_string(),
             Descriptor::ServiceDescriptor(value),
         );
 
-        // Group into Packages
-        let packages: HashMap<_, Package> =
-            descriptors
-                .into_values()
-                .fold(HashMap::new(), |mut acc, descriptor| {
-                    let package_name = descriptor.package_name();
-
-                    match acc.get_mut(package_name) {
-                        Some(package) => package.push_descriptor(descriptor),
-                        None => {
-                            let _ = acc.insert(package_name.to_string(), Package::from(descriptor));
-                        }
-                    }
-
-                    acc
-                });
-
+        let packages = group_descriptors_by_package(descriptors.into_values());
         Packages(packages)
     }
 }
 
+fn group_descriptors_by_package(
+    descriptors: impl IntoIterator<Item = Descriptor>,
+) -> HashMap<String, Package> {
+    descriptors
+        .into_iter()
+        .fold(HashMap::new(), |mut acc, descriptor| {
+            let package_name = descriptor.package_name();
+
+            match acc.get_mut(package_name) {
+                Some(package) => package.push_descriptor(descriptor),
+                None => {
+                    let _ = acc.insert(package_name.to_string(), Package::from(descriptor));
+                }
+            }
+
+            acc
+        })
+}
+
+fn collect_service_dependencies(service: &ServiceDescriptor) -> HashMap<String, Descriptor> {
+    service
+        .methods()
+        .flat_map(|m| [m.input(), m.output()])
+        .fold(HashMap::new(), |mut acc, d| {
+            let message_name = d.full_name().to_string();
+
+            if acc.contains_key(&message_name) {
+                return acc;
+            }
+
+            acc.insert(message_name, Descriptor::MessageDescriptor(d.clone()));
+
+            collect_message_dependencies(acc, &d)
+        })
+}
+
 fn collect_message_dependencies(
     descriptors: HashMap<String, Descriptor>,
     message: &MessageDescriptor,