Use a map instead of an imperatively built list; some borrowing

Author: msuchane

src/main.rs

@@ -90,7 +90,7 @@ fn main() {
         assert!(!include_statements.is_empty());
 
         // Generate the populated assembly module
-        let populated: Module = Input::new(ModuleType::Assembly, title, &options)
+        let populated: Module = Input::new(&ModuleType::Assembly, title, &options)
             .include(include_statements)
             .into();
 
@@ -105,26 +105,18 @@ fn process_module_type(
     module_type_str: &str,
     options: &Options,
 ) -> Vec<Module> {
-    let mut modules_from_type = Vec::new();
-
-    for title in titles {
-        // Convert the string module type to an enum.
-        // This must be done for each title separately so that the title can own the ModuleType.
-        let module_type = match module_type_str {
-            "assembly" => ModuleType::Assembly,
-            "include-in" => ModuleType::Assembly,
-            "concept" => ModuleType::Concept,
-            "procedure" => ModuleType::Procedure,
-            "reference" => ModuleType::Reference,
-            _ => unimplemented!(),
-        };
-
-        let module = Module::new(module_type, title, &options);
-
-        modules_from_type.push(module);
-    }
+    let module_type = match module_type_str {
+        "assembly" => ModuleType::Assembly,
+        "include-in" => ModuleType::Assembly,
+        "concept" => ModuleType::Concept,
+        "procedure" => ModuleType::Procedure,
+        "reference" => ModuleType::Reference,
+        _ => unimplemented!(),
+    };
+
+    let modules_from_type = titles.map(|title| Module::new(&module_type, title, &options));
 
-    modules_from_type
+    modules_from_type.collect()
 }
 
 // These tests act as pseudo-integration tests. They let the top-level functions generate
@@ -149,7 +141,7 @@ mod tests {
     /// Test that we generate the assembly that we expect.
     #[test]
     fn test_assembly() {
-        let mod_type = ModuleType::Assembly;
+        let mod_type = &ModuleType::Assembly;
         let mod_title = "Testing that an assembly forms properly";
         let options = basic_options();
         let assembly = Module::new(mod_type, mod_title, &options);
@@ -163,7 +155,7 @@ mod tests {
     /// Test that we generate the concept module that we expect.
     #[test]
     fn test_concept_module() {
-        let mod_type = ModuleType::Concept;
+        let mod_type = &ModuleType::Concept;
         let mod_title = "A title that tests a concept";
         let options = basic_options();
         let concept = Module::new(mod_type, mod_title, &options);
@@ -176,7 +168,7 @@ mod tests {
     /// Test that we generate the procedure module that we expect.
     #[test]
     fn test_procedure_module() {
-        let mod_type = ModuleType::Procedure;
+        let mod_type = &ModuleType::Procedure;
         let mod_title = "Testing a procedure";
         let options = basic_options();
         let procedure = Module::new(mod_type, mod_title, &options);
@@ -189,7 +181,7 @@ mod tests {
     /// Test that we generate the reference module that we expect.
     #[test]
     fn test_reference_module() {
-        let mod_type = ModuleType::Reference;
+        let mod_type = &ModuleType::Reference;
         let mod_title = "The lines in a reference module";
         let options = basic_options();
         let reference = Module::new(mod_type, mod_title, &options);

src/module.rs

@@ -7,7 +7,7 @@ use regex::{Regex, RegexBuilder};
 use crate::Options;
 
 /// All possible types of the AsciiDoc module
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub enum ModuleType {
     Assembly,
     Concept,
@@ -44,14 +44,14 @@ const REFERENCE_TEMPLATE: &str = include_str!("../data/templates/reference.adoc"
 
 /// Construct a basic builder for `Module`, storing information from the user input.
 impl Input {
-    pub fn new(mod_type: ModuleType, title: &str, options: &Options) -> Input {
+    pub fn new(mod_type: &ModuleType, title: &str, options: &Options) -> Input {
         debug!("Processing title `{}` of type `{:?}`", title, mod_type);
 
         let title = String::from(title);
         let options = options.clone();
 
         Input {
-            mod_type,
+            mod_type: *mod_type,
             title,
             options,
             includes: None,
@@ -330,7 +330,7 @@ impl From<Input> for Module {
     /// Convert the `Input` builder struct into the finished `Module` struct.
     fn from(input: Input) -> Self {
         let module = Module {
-            mod_type: input.mod_type.clone(),
+            mod_type: input.mod_type,
             title: input.title.clone(),
             id: input.id(),
             file_name: input.file_name(),
@@ -360,7 +360,7 @@ impl From<Input> for Module {
 impl Module {
     /// The constructor for the Module struct. Creates a basic version of Module
     /// without any optional features.
-    pub fn new(mod_type: ModuleType, title: &str, options: &Options) -> Module {
+    pub fn new(mod_type: &ModuleType, title: &str, options: &Options) -> Module {
         let input = Input::new(mod_type, title, options);
         input.into()
     }
@@ -397,7 +397,7 @@ mod tests {
     fn check_basic_assembly_fields() {
         let options = basic_options();
         let assembly = Module::new(
-            ModuleType::Assembly,
+            &ModuleType::Assembly,
             "A testing assembly with /special-characters*",
             &options,
         );
@@ -423,12 +423,12 @@ mod tests {
     fn check_module_builder_and_new() {
         let options = basic_options();
         let from_new: Module = Module::new(
-            ModuleType::Assembly,
+            &ModuleType::Assembly,
             "A testing assembly with /special-characters*",
             &options,
         );
         let from_builder: Module = Input::new(
-            ModuleType::Assembly,
+            &ModuleType::Assembly,
             "A testing assembly with /special-characters*",
             &options,
         )
@@ -440,7 +440,7 @@ mod tests {
     fn check_detected_path() {
         let options = path_options();
 
-        let module = Module::new(ModuleType::Procedure, "Testing the detected path", &options);
+        let module = Module::new(&ModuleType::Procedure, "Testing the detected path", &options);
 
         assert_eq!(
             module.include_statement,