Add feature to specify the name of the output folder

src/command.rs

@@ -0,0 +1,81 @@
+use std::option;
+use std::env::Args;
+
+#[derive(Debug)]
+enum Option {
+    Help,
+    Version,
+    InputPath(String),
+    OutputPath(String)
+}
+
+#[derive(Debug)]
+pub enum Command {
+    PrintHelp,
+    PrintVersion,
+    GenerateSite{ input_path: String, output_dir_path: String }
+}
+
+fn categorize_arg_tokens(mut args: Args) -> Vec<Option> {
+    let mut options = Vec::new();
+
+    args.next();
+    while let option::Option::Some(arg_token) = args.next() {
+        if arg_token == "-v" || arg_token == "--version" {
+            options.push(Option::Help);
+        } else if arg_token == "-h" || arg_token == "--help" {
+            options.push(Option::Version);
+        } else if arg_token == "-i" || arg_token == "--input" {
+            if let option::Option::Some(file_name) = args.next() {
+                options.push(Option::InputPath(file_name));
+            }
+        } else if arg_token == "-o" || arg_token == "--output" {
+            if let option::Option::Some(output_path) = args.next() {
+                options.push(Option::OutputPath(output_path));
+            }
+        }
+    }
+
+    options
+}
+
+fn parse_opts_as_command(opts: Vec<Option>) -> Command {
+    if opts.len() == 0 {
+        return Command::PrintHelp;
+    }
+
+    let mut opts = opts.into_iter();
+
+    let first_option = opts.next();
+
+    match first_option {
+        Some(Option::Help) => Command::PrintHelp,
+        Some(Option::Version) => Command::PrintVersion,
+        Some(Option::InputPath(input_path)) => {
+            let mut output_dir_path = String::from("dist");
+
+            while let Some(option) = opts.next() {
+                if let Option::OutputPath(output_path) = option {
+                    output_dir_path = output_path;
+                    break;
+                }
+            }
+
+            Command::GenerateSite{ input_path, output_dir_path }
+        },
+        Some(Option::OutputPath(output_dir_path)) => {
+            while let Some(option) = opts.next() {
+                if let Option::InputPath(input_path) = option {
+                    return Command::GenerateSite{ input_path, output_dir_path };
+                }
+            }
+
+            Command::PrintHelp
+        },
+        None => Command::PrintHelp
+    }
+}
+
+pub fn get_command_from_args(args: Args) -> Command {
+    parse_opts_as_command(categorize_arg_tokens(args))
+}

src/main.rs

@@ -1,69 +1,42 @@
 mod html_page;
 mod static_site;
+mod command;
 use static_site::StaticSite;
+use command::Command;
 use std::env;
 use std::path;
 
-enum Command {
-    Input { file_name: String },
-    Version,
-    Help,
-}
-
-impl Command {
-    fn from(mut args: env::Args) -> Option<Command> {
-        // Skip the first argument, which may not be the command name. See env::Args docs.
-        args.next();
-
-        let mut command = Option::None;
-
-        while let Option::Some(arg_token) = args.next() {
-            if arg_token == "-v" || arg_token == "--version" {
-                command = Option::Some(Command::Version);
-            } else if arg_token == "-h" || arg_token == "--help" {
-                command = Option::Some(Command::Help);
-            } else if arg_token == "-i" || arg_token == "--input" {
-                if let Option::Some(file_name) = args.next() {
-                    command = Option::Some(Command::Input { file_name });
-                }
-            }
-        }
-
-        command
-    }
-}
-
 const PKG_VERSION: &str = env!("CARGO_PKG_VERSION");
 const PKG_NAME: &str = env!("CARGO_PKG_NAME");
 
 fn main() -> std::io::Result<()> {
-    let command = Command::from(env::args());
+    let command = command::get_command_from_args(env::args());
 
-    let file_name = match command {
-        None | Some(Command::Help) => {
+    let site_options = match command {
+	Command::PrintHelp => {
             print_help();
             None
         }
-        Some(Command::Version) => {
+        Command::PrintVersion => {
             print_version();
             None
         }
-        Some(Command::Input { file_name }) => Some(file_name),
+        Command::GenerateSite { input_path, output_dir_path } => Some((input_path, output_dir_path)),
     };
 
-    if file_name == None {
+    if site_options == None {
         return Ok(());
-    }
+    } 
 
-    let file_name = file_name.unwrap();
+    let (file_name, output_dir) = site_options.unwrap();
     let input_path = path::Path::new(&file_name);
 
     if input_path.is_dir() {
         let site = StaticSite::from_directory(input_path)?;
-        site.create(path::Path::new("dist"))?;
+        site.create(path::Path::new(&output_dir))?;
     } else if input_path.is_file() {
         let site = StaticSite::from_file(input_path);
-        site.create(path::Path::new("dist"))?;
+        site.create(path::Path::new(&output_dir))?;
     }
 
     Ok(())