Proto file names no longer need to match package names when automatically finding config files

Author: YuhanLiin

micropb-gen/src/generator.rs

@@ -162,12 +162,18 @@ impl<'proto> Context<'proto> {
     }
 
     pub(crate) fn generate_fdset(
-        generator: Generator,
+        #[allow(unused_mut)] mut generator: Generator,
         fdset: &'proto FileDescriptorSet,
+        #[allow(unused)] find_config_files: bool,
     ) -> crate::Result<TokenStream> {
-        // Pre-generate the comment trees for every file
+        // Pre-generate the comment trees and configs for every file
         let mut comment_trees = vec![];
         for file in &fdset.file {
+            #[cfg(feature = "config-file")]
+            if find_config_files && let Some(name) = file.name() {
+                generator.parse_config_from_proto(std::path::Path::new(name), file.package())?;
+            }
+
             let mut comment_tree = PathTree::new(Comments::default());
             if let Some(src) = file.source_code_info() {
                 for location in &src.location {

micropb-gen/src/lib.rs

@@ -886,48 +886,37 @@ impl Generator {
         self
     }
 
+    #[cfg(feature = "config-file")]
+    pub(crate) fn parse_config_from_proto(
+        &mut self,
+        proto_path: &Path,
+        pkg: Option<&String>,
+    ) -> Result<()> {
+        let toml_path = proto_path.with_extension("toml");
+        let pkg_path = match pkg {
+            Some(pkg) => format!(".{pkg}"),
+            None => ".".to_owned(),
+        };
+        match self.parse_config_file(&toml_path, &pkg_path) {
+            // If config file doesn't exist then just assume there's no configs
+            Err(Error::Io(err)) if err.kind() == std::io::ErrorKind::NotFound => Ok(()),
+            Err(err) => Err(err),
+            Ok(()) => Ok(()),
+        }
+    }
+
     /// Compile `.proto` files and configuration files into a single Rust file.
     ///
     /// Configuration files are derived from the proto files by replacing the file extension with
     /// `.toml`. For example, if `server.proto` is passed in, the generator will look for the
-    /// `server.toml` config file and apply it to the `.server` package.
-    ///
-    /// <div class="warning">
-    /// The package name of each proto file must match the file name, because that's what the
-    /// generator assumes when applying the config files. For example, `client.rpc.proto` must
-    /// contain the specifier `package client.rpc;`.
-    /// </div>
+    /// `server.toml` config file and apply it to the package specified in `server.proto`.
     #[cfg(feature = "config-file")]
     pub fn compile_protos_with_config_files(
-        mut self,
+        self,
         protos: &[impl AsRef<Path>],
         out_filename: impl AsRef<Path>,
     ) -> Result<()> {
-        for proto_path in protos {
-            let proto_path = proto_path.as_ref();
-            if let Some(stem) = proto_path.file_stem().and_then(OsStr::to_str) {
-                let pkg = if stem.starts_with('.') {
-                    stem.to_owned()
-                } else {
-                    format!(".{stem}")
-                };
-                let toml_path = proto_path.with_extension("toml");
-
-                match self.parse_config_file(&toml_path, &pkg) {
-                    // If config file doesn't exist then just assume there's no configs
-                    Err(Error::Io(err)) if err.kind() == std::io::ErrorKind::NotFound => {}
-                    Err(err) => return Err(err),
-                    Ok(()) => {}
-                }
-            } else {
-                (self.warning_cb)(format_args!(
-                    "Couldn't derive config file path from {}",
-                    proto_path.display()
-                ));
-            }
-        }
-
-        self.compile_protos(protos, out_filename)
+        self.compile_protos_inner(protos, out_filename.as_ref(), true)
     }
 
     /// Compile `.proto` files into a single Rust file.
@@ -945,6 +934,15 @@ impl Generator {
         self,
         protos: &[impl AsRef<Path>],
         out_filename: impl AsRef<Path>,
+    ) -> Result<()> {
+        self.compile_protos_inner(protos, out_filename.as_ref(), false)
+    }
+
+    fn compile_protos_inner(
+        self,
+        protos: &[impl AsRef<Path>],
+        out_filename: &Path,
+        find_config_files: bool,
     ) -> Result<()> {
         let tmp;
         let fdset_file = if let Some(fdset_path) = &self.fdset_path {
@@ -978,7 +976,7 @@ impl Generator {
             ));
         }
 
-        self.compile_fdset_file(fdset_file, out_filename)
+        self.compile_fdset_file_inner(fdset_file.as_path(), out_filename, find_config_files)
     }
 
     /// Compile a Protobuf file descriptor set into a Rust file.
@@ -989,6 +987,15 @@ impl Generator {
         self,
         fdset_file: impl AsRef<Path>,
         out_filename: impl AsRef<Path>,
+    ) -> crate::Result<()> {
+        self.compile_fdset_file_inner(fdset_file.as_ref(), out_filename.as_ref(), false)
+    }
+
+    fn compile_fdset_file_inner(
+        self,
+        fdset_file: &Path,
+        out_filename: &Path,
+        find_config_files: bool,
     ) -> crate::Result<()> {
         #[allow(unused)]
         let format = self.format;
@@ -999,7 +1006,7 @@ impl Generator {
         fdset
             .decode(&mut decoder, bytes.len())
             .expect("file descriptor set decode failed");
-        let code = Context::generate_fdset(self, &fdset)?;
+        let code = Context::generate_fdset(self, &fdset, find_config_files)?;
 
         #[cfg(feature = "format")]
         let output = if format {

tests/basic-proto/build.rs

@@ -1,5 +1,3 @@
-use std::path::Path;
-
 use micropb_gen::{
     config::{CustomField, IntSize, OptionalRepr},
     Config, EncodeDecode, Generator,
@@ -535,19 +533,12 @@ fn minimal_accessors() {
 fn with_config_file() {
     let mut generator = Generator::new();
     generator.use_container_heapless();
-    generator
-        .parse_config_file(Path::new("proto/my.collections.toml"), ".")
-        .unwrap();
-    generator
-        .parse_config_file(Path::new("proto/my.map.toml"), ".")
-        .unwrap();
 
     generator
         .compile_protos_with_config_files(
             &[
                 "proto/collections.proto",
                 "proto/map.proto",
-                // Only basic.toml will be picked up my this function
                 "proto/basic.proto",
             ],
             std::env::var("OUT_DIR").unwrap() + "/with_config_file.rs",