Add an optional flag for automatically filling out the include path; #16

Author: msuchane

src/cmd_line.rs

@@ -73,11 +73,17 @@ pub fn get_args() -> ArgMatches<'static> {
                 .long("no-comments")
                 .help("Generate the file without any comments"),
         )
+        .arg(
+            Arg::with_name("detect-directory")
+            .short("D")
+            .long("detect-directory")
+            .help("Detect the include path, rather than using the <path> placeholder")
+        )
         .arg(
             Arg::with_name("no-prefixes")
                 .short("P")
                 .long("no-prefixes")
-                .help("Do not use module type prefixes (e.g. `proc_`) in file names"),
+                .help("Do not use module type prefixes (such as `proc_`) in file names"),
         )
         .arg(
             Arg::with_name("target-dir")

src/main.rs

@@ -11,6 +11,7 @@ pub struct Options {
     comments: bool,
     prefixes: bool,
     target_dir: String,
+    detect_directory: bool,
 }
 
 fn main() {
@@ -29,6 +30,7 @@ fn main() {
         } else {
             String::from(".")
         },
+        detect_directory: cmdline_args.is_present("detect-directory"),
     };
 
     // Store all modules except for the populated assembly that will be created in this Vec

src/module.rs

@@ -155,7 +155,24 @@ impl Input {
 
     /// Prepare an include statement that can be used to include the generated file from elsewhere.
     fn include_statement(&self) -> String {
-        // Determine the start of the include statement from the target path.
+        let path_placeholder = Path::new("<path>").to_path_buf();
+
+        let include_path = if self.options.detect_directory {
+            match self.infer_include_dir() {
+                Some(path) => path,
+                None => path_placeholder,
+            }
+        } else {
+            path_placeholder
+        };
+
+        format!("include::{}/{}[leveloffset=+1]", include_path.display(), &self.file_name())
+    }
+
+    /// Determine the start of the include statement from the target path.
+    /// Returns the relative path that can be used in the include statement, if it's possible
+    /// to determine it automatically.
+    fn infer_include_dir(&self) -> Option<PathBuf> {
         // The first directory in the include path is either `assemblies/` or `modules/`,
         // based on the module type.
         let include_root = match &self.mod_type {
@@ -179,19 +196,19 @@ impl Input {
 
         // If there is such a root element in the path, construct the include path.
         // TODO: To be safe, check that the root path element still exists in a Git repository.
-        let include_path = if let Some(position) = root_position {
-            component_vec
+        if let Some(position) = root_position {
+            let include_path = component_vec
                 .split_off(position)
                 .iter()
-                .collect::<PathBuf>()
+                .collect::<PathBuf>();
+            Some(include_path)
         // If no appropriate root element was found, use a generic placeholder.
         } else {
-            Path::new("<path>").to_path_buf()
-        };
-
-        format!("include::{}/{}[leveloffset=+1]", include_path.display(), &self.file_name())
+            None
+        }
     }
 
+
     /// Perform string replacements in the modular template that matches the `ModuleType`.
     /// Return the template text with all replacements.
     pub fn text(&self) -> String {