feat(lib): Allow more output modes

Allow multiple "output modes", and add two new:

- `OutputMode::SingleFile`: Write all bindings to a single file. Previously the only mode.
- `OutputMode::Stdout`: Write all bindings to stdout.
- `OutputMode::NoOutput`: Do not write anything. Useful when only checking.

This is a small step towards outputting a file per module (issue #53).

Author: Rawk

rasn-compiler-tests/tests/parse_test.rs

@@ -1,4 +1,4 @@
-use rasn_compiler::{prelude::RasnBackend, Compiler};
+use rasn_compiler::{prelude::RasnBackend, Compiler, OutputMode};
 
 #[test]
 #[ignore]
@@ -57,7 +57,7 @@ fn compile_etsi() {
             // .add_asn_by_path("../rasn-compiler/test_asn1/ngap_ies.asn")
             // .add_asn_by_path("../rasn-compiler/test_asn1/ngap_pdus.asn")
             .add_asn_by_path("../rasn-compiler/test_asn1/test.asn")
-            .set_output_path("./tests")
+            .set_output_mode(OutputMode::SingleFile("./tests".into()))
             .compile()
     );
 }

rasn-compiler/src/lib.rs

@@ -13,6 +13,7 @@ use std::{
     cell::RefCell,
     collections::BTreeMap,
     fs::{self, read_to_string},
+    io::Write,
     path::PathBuf,
     rc::Rc,
     vec,
@@ -133,15 +134,15 @@ impl Default for CompilerMissingParams {
 /// Typestate representing compiler that is ready to compile
 pub struct CompilerReady {
     sources: Vec<AsnSource>,
-    output_path: PathBuf,
+    output_mode: OutputMode,
 }
 
-/// Typestate representing compiler that has the output path set, but is missing ASN1 sources
+/// Typestate representing compiler that has the output mode set, but is missing ASN1 sources
 pub struct CompilerOutputSet {
-    output_path: PathBuf,
+    output_mode: OutputMode,
 }
 
-/// Typestate representing compiler that knows about ASN1 sources, but doesn't have an output path set
+/// Typestate representing compiler that knows about ASN1 sources, but doesn't have an output mode set
 pub struct CompilerSourcesSet {
     sources: Vec<AsnSource>,
 }
@@ -254,19 +255,26 @@ impl<B: Backend> Compiler<B, CompilerMissingParams> {
         }
     }
 
-    /// Set the output path for the generated rust representation.
-    /// * `output_path` - path to an output file or directory, if path indicates
-    ///   a directory, the output file is named `rasn_generated.rs`
+    /// Set the output path for the generated bindings.
+    /// * `output_path` - path to an output file or directory, if path indicates a directory, the
+    ///   output file is named `generated` with the extension used by the Backend.
+    #[deprecated = "Use `Self::set_output_mode` instead"]
     pub fn set_output_path(
         self,
         output_path: impl Into<PathBuf>,
     ) -> Compiler<B, CompilerOutputSet> {
-        let mut path: PathBuf = output_path.into();
-        if path.is_dir() {
-            path.set_file_name("rasn_generated.rs");
+        Compiler {
+            state: CompilerOutputSet {
+                output_mode: OutputMode::SingleFile(output_path.into()),
+            },
+            backend: self.backend,
         }
+    }
+
+    /// Set the output destination for the generated bindings.
+    pub fn set_output_mode(self, output_mode: OutputMode) -> Compiler<B, CompilerOutputSet> {
         Compiler {
-            state: CompilerOutputSet { output_path: path },
+            state: CompilerOutputSet { output_mode },
             backend: self.backend,
         }
     }
@@ -279,7 +287,7 @@ impl<B: Backend> Compiler<B, CompilerOutputSet> {
         Compiler {
             state: CompilerReady {
                 sources: vec![AsnSource::Path(path_to_source.into())],
-                output_path: self.state.output_path,
+                output_mode: self.state.output_mode,
             },
             backend: self.backend,
         }
@@ -296,7 +304,7 @@ impl<B: Backend> Compiler<B, CompilerOutputSet> {
                 sources: paths_to_sources
                     .map(|p| AsnSource::Path(p.into()))
                     .collect(),
-                output_path: self.state.output_path,
+                output_mode: self.state.output_mode,
             },
             backend: self.backend,
         }
@@ -315,7 +323,7 @@ impl<B: Backend> Compiler<B, CompilerOutputSet> {
         Compiler {
             state: CompilerReady {
                 sources: vec![AsnSource::Literal(literal.into())],
-                output_path: self.state.output_path,
+                output_mode: self.state.output_mode,
             },
             backend: self.backend,
         }
@@ -369,15 +377,26 @@ impl<B: Backend> Compiler<B, CompilerSourcesSet> {
         }
     }
 
-    /// Set the output path for the generated rust representation.
-    /// * `output_path` - path to an output file or directory, if path points to
-    ///   a directory, the compiler will generate a file for every ASN.1 module.
-    ///   If the path points to a file, all modules will be written to that file.
+    /// Set the output path for the generated bindings.
+    /// * `output_path` - path to an output file or directory, if path indicates a directory, the
+    ///   output file is named `generated` with the extension used by the Backend.
+    #[deprecated = "Use `Self::set_output_mode` instead"]
     pub fn set_output_path(self, output_path: impl Into<PathBuf>) -> Compiler<B, CompilerReady> {
         Compiler {
             state: CompilerReady {
                 sources: self.state.sources,
-                output_path: output_path.into(),
+                output_mode: OutputMode::SingleFile(output_path.into()),
+            },
+            backend: self.backend,
+        }
+    }
+
+    /// Set the output destination for the generated bindings.
+    pub fn set_output_mode(self, output_mode: OutputMode) -> Compiler<B, CompilerReady> {
+        Compiler {
+            state: CompilerReady {
+                sources: self.state.sources,
+                output_mode,
             },
             backend: self.backend,
         }
@@ -387,64 +406,9 @@ impl<B: Backend> Compiler<B, CompilerSourcesSet> {
     /// Returns a Result wrapping a compilation result:
     /// * _Ok_  - tuple containing the stringified bindings for the ASN1 spec as well as a vector of warnings raised during the compilation
     /// * _Err_ - Unrecoverable error, no bindings were generated
-    pub fn compile_to_string(mut self) -> Result<CompileResult, CompilerError> {
-        self.internal_compile().map(CompileResult::fmt::<B>)
-    }
-
-    fn internal_compile(&mut self) -> Result<CompileResult, CompilerError> {
-        let mut generated_modules = vec![];
-        let mut warnings = Vec::<CompilerError>::new();
-        let mut modules: Vec<ToplevelDefinition> = vec![];
-        for src in &self.state.sources {
-            let stringified_src = match src {
-                AsnSource::Path(p) => read_to_string(p).map_err(LexerError::from)?,
-                AsnSource::Literal(l) => l.clone(),
-            };
-            modules.append(
-                &mut asn_spec(&stringified_src)?
-                    .into_iter()
-                    .flat_map(|(header, tlds)| {
-                        let header_ref = Rc::new(RefCell::new(header));
-                        tlds.into_iter().map(move |mut tld| {
-                            tld.apply_tagging_environment(&header_ref.borrow().tagging_environment);
-                            tld.set_module_header(header_ref.clone());
-                            tld
-                        })
-                    })
-                    .collect(),
-            );
-        }
-        let (valid_items, mut validator_errors) = Validator::new(modules).validate()?;
-        let modules = valid_items.into_iter().fold(
-            BTreeMap::<String, Vec<ToplevelDefinition>>::new(),
-            |mut modules, tld| {
-                let key = tld
-                    .get_module_header()
-                    .map_or(<_>::default(), |module| module.borrow().name.clone());
-                match modules.entry(key) {
-                    std::collections::btree_map::Entry::Vacant(v) => {
-                        v.insert(vec![tld]);
-                    }
-                    std::collections::btree_map::Entry::Occupied(ref mut e) => {
-                        e.get_mut().push(tld)
-                    }
-                }
-                modules
-            },
-        );
-        for (_, module) in modules {
-            let mut generated_module = self.backend.generate_module(module)?;
-            if let Some(m) = generated_module.generated {
-                generated_modules.push(m);
-            }
-            warnings.append(&mut generated_module.warnings);
-        }
-        warnings.append(&mut validator_errors);
-
-        Ok(CompileResult {
-            generated: generated_modules.join("\n"),
-            warnings,
-        })
+    pub fn compile_to_string(self) -> Result<CompileResult, CompilerError> {
+        self.set_output_mode(OutputMode::NoOutput)
+            .compile_to_string()
     }
 }
 
@@ -456,7 +420,7 @@ impl<B: Backend> Compiler<B, CompilerReady> {
         sources.push(AsnSource::Path(path_to_source.into()));
         Compiler {
             state: CompilerReady {
-                output_path: self.state.output_path,
+                output_mode: self.state.output_mode,
                 sources,
             },
             backend: self.backend,
@@ -474,7 +438,7 @@ impl<B: Backend> Compiler<B, CompilerReady> {
         Compiler {
             state: CompilerReady {
                 sources,
-                output_path: self.state.output_path,
+                output_mode: self.state.output_mode,
             },
             backend: self.backend,
         }
@@ -494,7 +458,7 @@ impl<B: Backend> Compiler<B, CompilerReady> {
         sources.push(AsnSource::Literal(literal.into()));
         Compiler {
             state: CompilerReady {
-                output_path: self.state.output_path,
+                output_mode: self.state.output_mode,
                 sources,
             },
             backend: self.backend,
@@ -505,43 +469,121 @@ impl<B: Backend> Compiler<B, CompilerReady> {
     /// Returns a Result wrapping a compilation result:
     /// * _Ok_  - tuple containing the stringified bindings for the ASN1 spec as well as a vector of warnings raised during the compilation
     /// * _Err_ - Unrecoverable error, no bindings were generated
-    pub fn compile_to_string(self) -> Result<CompileResult, CompilerError> {
-        Compiler {
-            state: CompilerSourcesSet {
-                sources: self.state.sources,
-            },
-            backend: self.backend,
-        }
-        .compile_to_string()
+    pub fn compile_to_string(mut self) -> Result<CompileResult, CompilerError> {
+        self.internal_compile().map(CompileResult::fmt::<B>)
     }
 
     /// Runs the rasn compiler command.
     /// Returns a Result wrapping a compilation result:
     /// * _Ok_  - Vector of warnings raised during the compilation
     /// * _Err_ - Unrecoverable error, no bindings were generated
-    pub fn compile(self) -> Result<Vec<CompilerError>, CompilerError> {
-        let result = Compiler {
-            state: CompilerSourcesSet {
-                sources: self.state.sources,
+    pub fn compile(mut self) -> Result<Vec<CompilerError>, CompilerError> {
+        let result = self.internal_compile()?.fmt::<B>();
+
+        self.output_generated(&result.generated)?;
+
+        Ok(result.warnings)
+    }
+
+    fn internal_compile(&mut self) -> Result<CompileResult, CompilerError> {
+        let mut generated_modules = vec![];
+        let mut warnings = Vec::<CompilerError>::new();
+        let mut modules: Vec<ToplevelDefinition> = vec![];
+        for src in &self.state.sources {
+            let stringified_src = match src {
+                AsnSource::Path(p) => read_to_string(p).map_err(LexerError::from)?,
+                AsnSource::Literal(l) => l.clone(),
+            };
+            modules.append(
+                &mut asn_spec(&stringified_src)?
+                    .into_iter()
+                    .flat_map(|(header, tlds)| {
+                        let header_ref = Rc::new(RefCell::new(header));
+                        tlds.into_iter().map(move |mut tld| {
+                            tld.apply_tagging_environment(&header_ref.borrow().tagging_environment);
+                            tld.set_module_header(header_ref.clone());
+                            tld
+                        })
+                    })
+                    .collect(),
+            );
+        }
+        let (valid_items, mut validator_errors) = Validator::new(modules).validate()?;
+        let modules = valid_items.into_iter().fold(
+            BTreeMap::<String, Vec<ToplevelDefinition>>::new(),
+            |mut modules, tld| {
+                let key = tld
+                    .get_module_header()
+                    .map_or(<_>::default(), |module| module.borrow().name.clone());
+                match modules.entry(key) {
+                    std::collections::btree_map::Entry::Vacant(v) => {
+                        v.insert(vec![tld]);
+                    }
+                    std::collections::btree_map::Entry::Occupied(ref mut e) => {
+                        e.get_mut().push(tld)
+                    }
+                }
+                modules
             },
-            backend: self.backend,
+        );
+        for (_, module) in modules {
+            let mut generated_module = self.backend.generate_module(module)?;
+            if let Some(m) = generated_module.generated {
+                generated_modules.push(m);
+            }
+            warnings.append(&mut generated_module.warnings);
         }
-        .internal_compile()?
-        .fmt::<B>();
-
-        let output_file = if self.state.output_path.is_dir() {
-            self.state
-                .output_path
-                .join(format!("generated{}", B::FILE_EXTENSION))
-        } else {
-            self.state.output_path
-        };
-        fs::write(output_file, result.generated).map_err(|e| GeneratorError {
-            top_level_declaration: None,
-            details: e.to_string(),
-            kind: GeneratorErrorType::IO,
-        })?;
+        warnings.append(&mut validator_errors);
 
-        Ok(result.warnings)
+        Ok(CompileResult {
+            generated: generated_modules.join("\n"),
+            warnings,
+        })
     }
+
+    fn output_generated(&self, generated: &str) -> Result<(), GeneratorError> {
+        match &self.state.output_mode {
+            OutputMode::SingleFile(path) => {
+                let path = if path.is_dir() {
+                    &path.join(format!("generated{}", B::FILE_EXTENSION))
+                } else {
+                    path
+                };
+                fs::write(path, generated).map_err(|e| {
+                    GeneratorError::new(
+                        None,
+                        &format!(
+                            "Failed to write generated bindings to {}: {e}",
+                            path.display()
+                        ),
+                        GeneratorErrorType::IO,
+                    )
+                })
+            }
+            OutputMode::Stdout => {
+                std::io::stdout()
+                    .write_all(generated.as_bytes())
+                    .map_err(|err| {
+                        GeneratorError::new(
+                            None,
+                            &format!("Failed to write generated bindings to stdout: {err}"),
+                            GeneratorErrorType::IO,
+                        )
+                    })
+            }
+            OutputMode::NoOutput => Ok(()),
+        }
+    }
+}
+
+/// Where the [Compiler] output should go.
+#[derive(Debug)]
+pub enum OutputMode {
+    /// Write all compiled modules to a single file. Uses a default filename if path is a
+    /// directory.
+    SingleFile(PathBuf),
+    /// Write all compiled modules to stdout.
+    Stdout,
+    /// Do not write anything, only check.
+    NoOutput,
 }