Add raw schema output option to capnpc.

Author: freopen

capnpc/src/codegen.rs

@@ -36,6 +36,7 @@ use self::FormattedText::{Indent, Line, Branch, BlankLine};
 pub struct CodeGenerationCommand {
     output_directory: PathBuf,
     default_parent_module: Vec<String>,
+    raw_code_generator_request_path: Option<PathBuf>,
 }
 
 impl CodeGenerationCommand {
@@ -44,6 +45,7 @@ impl CodeGenerationCommand {
         CodeGenerationCommand {
             output_directory: PathBuf::new(),
             default_parent_module: Vec::new(),
+            raw_code_generator_request_path: None,
         }
     }
 
@@ -65,6 +67,14 @@ impl CodeGenerationCommand {
         self
     }
 
+    /// Sets the raw code generator request output path.
+    pub fn raw_code_generator_request_path<P>(&mut self, path: P) -> &mut Self
+        where P: AsRef<Path>
+    {
+        self.raw_code_generator_request_path = Some(path.as_ref().to_path_buf());
+        self
+    }
+
     /// Generates Rust code according to a `schema_capnp::code_generator_request` read from `inp`.
     pub fn run<T>(&mut self, inp: T) -> ::capnp::Result<()>
         where T: std::io::Read
@@ -119,6 +129,12 @@ impl CodeGenerationCommand {
                 }
             }
         }
+
+        if let Some(raw_code_generator_request) = &self.raw_code_generator_request_path {
+            let raw_code_generator_request_file = ::std::fs::File::create(&raw_code_generator_request).map_err(convert_io_err)?;
+            serialize::write_message_segments(WriteWrapper{ inner: raw_code_generator_request_file }, &message.into_segments())?;
+        }
+
         Ok(())
     }
 }
@@ -2065,6 +2081,19 @@ impl <R> capnp::io::Read for ReadWrapper<R> where R: std::io::Read {
     }
 }
 
+// The capnp crate defines a blanket impl of capnp::Write for R where R: std::io::Write,
+// but we can't use that here because it lives behind the "std" feature flag.
+struct WriteWrapper<W> where W: std::io::Write {
+    inner: W,
+}
+
+impl <W> capnp::io::Write for WriteWrapper<W> where W: std::io::Write {
+    fn write_all(&mut self, buf: &[u8]) -> ::capnp::Result<()> {
+        std::io::Write::write_all(&mut self.inner, buf).map_err(convert_io_err)?;
+        Ok(())
+    }
+}
+
 #[deprecated(since = "0.14.2", note = "Use CodeGenerationCommand::run() instead.")]
 pub fn generate_code<T>(inp: T, out_dir: &::std::path::Path) -> ::capnp::Result<()>
     where T: ::std::io::Read

capnpc/src/lib.rs

@@ -105,6 +105,7 @@ pub struct CompilerCommand {
     executable_path: Option<PathBuf>,
     output_path: Option<PathBuf>,
     default_parent_module: Vec<String>,
+    raw_code_generator_request_path: Option<PathBuf>,
 }
 
 impl CompilerCommand {
@@ -118,6 +119,7 @@ impl CompilerCommand {
             executable_path: None,
             output_path: None,
             default_parent_module: Vec::new(),
+            raw_code_generator_request_path: None,
         }
     }
 
@@ -200,6 +202,16 @@ impl CompilerCommand {
         self
     }
 
+    /// If set, the generator will also write a file containing the raw code generator request to the
+    /// specified path.
+    pub fn raw_code_generator_request_path<P>(&mut self, path: P) -> &mut CompilerCommand
+    where
+        P: AsRef<Path>,
+    {
+        self.raw_code_generator_request_path = Some(path.as_ref().to_path_buf());
+        self
+    }
+
     /// Runs the command.
     /// Returns an error if `OUT_DIR` or a custom output directory was not set, or if `capnp compile` fails.
     pub fn run(&mut self) -> ::capnp::Result<()> {
@@ -263,6 +275,9 @@ impl CompilerCommand {
         code_generation_command
             .output_directory(output_path)
             .default_parent_module(self.default_parent_module.clone());
+        if let Some(raw_code_generator_request_path) = &self.raw_code_generator_request_path {
+            code_generation_command.raw_code_generator_request_path(raw_code_generator_request_path.clone());
+        }
 
         run_command(command, code_generation_command).map_err(|error| {
             ::capnp::Error::failed(format!(

capnpc/test/Cargo.toml

@@ -15,3 +15,4 @@ capnpc = { path = "../" }
 
 [dependencies]
 capnp = { path = "../../capnp" }
+capnpc = { path = "../" }

capnpc/test/build.rs

@@ -6,6 +6,10 @@ fn main() {
         .file("schema/test-in-dir.capnp")
         .file("schema-with-src-prefix/test-in-src-prefix-dir.capnp")
         .src_prefix("schema-with-src-prefix")
+        .raw_code_generator_request_path(
+            std::env::var("OUT_DIR").expect("OUT_DIR env var is not set")
+                + "/raw_code_gen_request.bin",
+        )
         .run()
         .expect("compiling schema");
 

capnpc/test/test.rs

@@ -1645,4 +1645,20 @@ mod tests {
         let message_reader = TypedReader::<_, test_all_types::Owned>::new(reader);
         ::test_util::CheckTestMessage::check_test_message(message_reader.get().unwrap());
     }
+
+    #[test] 
+    fn test_raw_code_generator_request_path() {
+        use std::fs;
+        use capnp::serialize;
+
+        let raw_code_gen_request = fs::read(
+            std::env::var("OUT_DIR").expect("OUT_DIR env var is not set")
+                + "/raw_code_gen_request.bin"
+        ).expect("Failed to open raw code gen request file");
+
+        let reader = serialize::read_message(raw_code_gen_request.as_slice(), ReaderOptions::new()).unwrap();
+        let generator_context = capnpc::codegen::GeneratorContext::new(&reader).unwrap();
+        assert!(generator_context.node_map.len() > 0);
+        assert!(generator_context.scope_map.len() > 0);
+    }
 }